<!DOCTYPE html>
<html class="client-nojs vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-0 vector-toc-not-available vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-0 vector-feature-night-mode-enabled skin-theme-clientpref-os vector-sticky-header-enabled" lang="fr" dir="ltr"><head>
<meta charset="UTF-8">
<title>Lua</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" type="image/png" href="./_res_/favicon.png">
<link rel="canonical" href="https://fr.wikipedia.org/wiki/Lua"> <link href="./_mw_/ext.cite.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.wikimediamessages.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link rel="stylesheet" type="text/css" href="./_mw_/site.styles.css">
<link rel="stylesheet" type="text/css" href="./_mw_/noscript.css">
<link rel="stylesheet" type="text/css" href="./_res_/footer.css">
<link rel="stylesheet" type="text/css" href="./_res_/vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Lua rootpage-Lua skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading"><span class="mw-page-title-main">Lua</span></h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="contentSub">
<div id="mw-content-subtitle"></div>
</div>
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="fr" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="fr" dir="ltr">
<p class="mw-empty-elt">
</p>
<table class="infobox_v2 infobox infobox--frwiki noarchive">
<tbody><tr>
<td colspan="2" class="entete informatique" style="background-color:#010080;color:black;"><span style="color: #fff;">Lua</span><style data-mw-deduplicate="TemplateStyles:r228712691">
/* start https://fr.wikipedia.org/ */
.mw-parser-output .entete.informatique{background-image:url("./_mw_/Picto.nfo.png")}
/* end https://fr.wikipedia.org/ */
</style>
</td></tr>
<tr><td colspan="3" style="text-align:center; line-height: 1.5em;"> </td></tr>
<tr>
<td colspan="2"><hr style="height:2px; color:inherit; background-color:#010080;"></td></tr>
<tr>
<th scope="row">Date de première version
</th>
<td><a href="1993_en_informatique" title="1993 en informatique">1993</a>
</td>
</tr>
<tr>
<th scope="row"><a href="Paradigme_(programmation)" title="Paradigme (programmation)">Paradigme</a>
</th>
<td>Multi-paradigme : <a href="Programmation_proc%C3%A9durale" title="Programmation procédurale">procédural</a>, <a href="Programmation_orient%C3%A9e_prototype" title="Programmation orientée prototype">orienté objet à prototype</a> et <a href="Programmation_fonctionnelle" title="Programmation fonctionnelle">fonctionnel</a>
</td>
</tr>
<tr>
<th scope="row">Auteur
</th>
<td>Luiz Henrique de Figueiredo, Roberto Ierusalimschy et Waldemar Celes
</td>
</tr>
<tr>
<th scope="row"><a href="Version_d'un_logiciel" title="Version d'un logiciel">Dernière version</a>
</th>
<td><span class="wd_p348">5.4.8 (<time class="nowrap date-lien" datetime="2025-06-04" data-sort-value="2025-06-04"><a href="4_juin" title="4 juin">4</a> <a href="Juin_2025" title="Juin 2025">juin</a> <a href="2025" title="2025">2025</a></time>)<sup id="cite_ref-wikidata-0a30228504911f642387a91b3bc4df31672ca70c_1-1" class="reference"><a href="#cite_note-wikidata-0a30228504911f642387a91b3bc4df31672ca70c-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup></span>
</td>
</tr>
<tr>
<th scope="row">Typage
</th>
<td><a href="Typage_dynamique" title="Typage dynamique">dynamique</a>, <a href="Typage#Typage_fort_et_typage_faible" class="mw-redirect" title="Typage">faible</a>
</td>
</tr>
<tr>
<th scope="row">Influencé par
</th>
<td><a href="BASIC" class="mw-redirect" title="BASIC">BASIC</a>, <a href="C_(langage)" title="C (langage)">C</a>, <a href="C%2B%2B" title="C++">C++</a>
</td>
</tr>
<tr>
<th scope="row">A influencé
</th>
<td><a href="Micro_Lua_DS" title="Micro Lua DS">Micro Lua DS</a>
</td>
</tr>
<tr>
<th scope="row">Implémentations
</th>
<td><a rel="nofollow" class="external text" href="http://www.lua.org">Lua</a>, <a rel="nofollow" class="external text" href="http://luajit.org">LuaJIT</a>, <a rel="nofollow" class="external text" href="https://code.google.com/p/llvm-lua">LLVM-Lua</a>, <a rel="nofollow" class="external text" href="https://code.google.com/p/luaclr">LuaCLR</a>, <a rel="nofollow" class="external text" href="http://nua.codeplex.com">Nua</a>, <a rel="nofollow" class="external text" href="https://code.google.com/p/lua-alchemy">Lua Alchemy</a>, <a rel="nofollow" class="external text" href="http://microlua.xooit.fr">MicroLua</a>,
<p><a rel="nofollow" class="external text" href="https://code.google.com/p/mochalua">Mochalua</a>, <a rel="nofollow" class="external text" href="https://code.google.com/p/jillcode">Jill</a>, <a rel="nofollow" class="external text" href="http://luaj.org/luaj/README.html">luaj</a>,
<a rel="nofollow" class="external text" href="https://www.luart.org">LuaRT</a>
</p>
</td>
</tr>
<tr>
<th scope="row"><a href="Langage_de_programmation" title="Langage de programmation">Écrit en</a>
</th>
<td><span class="wd_p277"><a href="C_(langage)" title="C (langage)">C</a></span>
</td>
</tr>
<tr>
<th scope="row"><a href="Syst%C3%A8me_d'exploitation" title="Système d'exploitation">Système d'exploitation</a>
</th>
<td><a href="Multiplate-forme" class="mw-redirect" title="Multiplate-forme">Multiplate-forme</a>
</td>
</tr>
<tr>
<th scope="row"><a href="Licence_de_logiciel" title="Licence de logiciel">Licence</a>
</th>
<td><a href="Licence_MIT" title="Licence MIT">Licence MIT</a>
</td>
</tr>
<tr>
<th scope="row"><a href="Site_web" title="Site web">Site web</a>
</th>
<td><a rel="nofollow" class="external text" href="https://www.lua.org/">lua.org</a>
</td>
</tr>
<tr>
<th scope="row"><a href="Extension_de_nom_de_fichier" title="Extension de nom de fichier">Extension de fichier</a>
</th>
<td><span class="wd_p1195">lua, luna, lunaire et anair</span>
</td>
</tr>
<tr>
</tr>
</tbody></table>
<p><b>Lua</b> est un <a href="Langage_de_script" title="Langage de script">langage de script</a> <a href="Logiciel_libre" title="Logiciel libre">libre</a>, <a href="R%C3%A9flexion_(informatique)" title="Réflexion (informatique)">réflexif</a> et <a href="Programmation_imp%C3%A9rative" title="Programmation impérative">impératif</a>. Il intègre un <a href="Ramasse-miettes_(informatique)" title="Ramasse-miettes (informatique)">ramasse-miettes</a>, et il est conçu de manière à pouvoir être embarqué dans d'autres applications pour les étendre.
</p><p>Lua (du <a href="Portugais" title="Portugais">portugais</a> : <span class="lang-pt" lang="pt"><a href="https://fr.wiktionary.org/wiki/lua#pt" class="extiw external" title="wikt:lua">Lua</a></span> <span title="Alphabet phonétique international" class="API" style="font-family:'DejaVu Sans','Doulos SIL','Lucida Grande','Segoe UI','Arial Unicode MS','Adobe Pi Std','Lucida Sans Unicode','Chrysanthi Unicode',Code2000,Gentium,GentiumAlt,'TITUS Cyberbit Basic','Bitstream Vera Sans','Bitstream Cyberbit','Hiragino Kaku Gothic Pro','Matrix Unicode',sans-serif;"><a href="Alphabet_phon%C3%A9tique_international" title="Alphabet phonétique international"><span class="nowrap">[ˈlu.ɐ]</span></a></span>, au <a href="Br%C3%A9sil" title="Brésil">Brésil</a> : <span title="Alphabet phonétique international" class="API" style="font-family:'DejaVu Sans','Doulos SIL','Lucida Grande','Segoe UI','Arial Unicode MS','Adobe Pi Std','Lucida Sans Unicode','Chrysanthi Unicode',Code2000,Gentium,GentiumAlt,'TITUS Cyberbit Basic','Bitstream Vera Sans','Bitstream Cyberbit','Hiragino Kaku Gothic Pro','Matrix Unicode',sans-serif;"><a href="Alphabet_phon%C3%A9tique_international" title="Alphabet phonétique international"><span class="nowrap">[ˈlu.a]</span></a></span>, signifiant « <a href="Lune" title="Lune">Lune</a> »<sup id="cite_ref-2" class="reference"><a href="#cite_note-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup>), a été développé en <a href="1993_en_informatique" title="1993 en informatique">1993</a> par Luiz Henrique de Figueiredo, Roberto Ierusalimschy <a href="https://en.wikipedia.org/wiki/Roberto_Ierusalimschy" class="extiw external" title="en:Roberto Ierusalimschy"><span class="indicateur-langue" title="Article en anglais : « Roberto Ierusalimschy »">(en)</span></a> et Waldemar Celes, membres du groupe de recherche TeCGraf, de l'<a href="Universit%C3%A9_pontificale_catholique_de_Rio_de_Janeiro" title="Université pontificale catholique de Rio de Janeiro">université pontificale catholique de Rio de Janeiro</a> au <a href="Br%C3%A9sil" title="Brésil">Brésil</a>.
</p><p>L'interpréteur Lua est écrit en <a href="C_(langage)" title="C (langage)">langage C</a> <a href="ANSI" class="mw-redirect" title="ANSI">ANSI</a> strict, ce qui le rend compilable sur beaucoup de systèmes. Il est aussi très compact, la version 5.0.2 n'occupant que 95 <abbr class="abbr" title="kilooctet">ko</abbr> à 185 <abbr class="abbr" title="kilooctet">ko</abbr> selon le <a href="Compilateur" title="Compilateur">compilateur</a> utilisé et le système cible. L’existence d’interfaces entre C et de nombreux langages facilite l’intégration de Lua dans la plupart des projets.
</p><p>Sa compacité et son extensibilité le font particulièrement apprécier pour l'embarqué, le développement <a href="R%C3%A9seau" title="Réseau">réseau</a> et les <a href="Jeu_vid%C3%A9o" title="Jeu vidéo">jeux vidéo</a>.
</p>
<div class="mw-heading mw-heading2"><h2 id="Généralités"><span id="G.C3.A9n.C3.A9ralit.C3.A9s"></span>Généralités</h2></div>
<div class="mw-heading mw-heading3"><h3 id="Commentaires">Commentaires</h3></div><p>
En Lua, les <a href="Commentaire_(informatique)" title="Commentaire (informatique)">commentaires</a> débutent par <code>--</code> et finissent à la fin de la ligne, comme en <a href="Ada_(langage)" title="Ada (langage)">Ada</a>. Si la première ligne commence par <code>#!</code> (<a href="Shebang" title="Shebang">shebang</a>) elle est aussi traitée comme un commentaire. Les commentaires multilignes sont également disponibles avec la syntaxe </p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="cm">--[[...]]</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Variables">Variables</h3></div>
<p>Une <a href="Variable_(informatique)" title="Variable (informatique)">variable</a> peut contenir un <a href="Bool%C3%A9en" title="Booléen">booléen</a>, une <a href="Cha%C3%AEne_de_caract%C3%A8res" title="Chaîne de caractères">chaîne de caractères</a>, un nombre (pas de différence entre <a href="Entier_(informatique)" title="Entier (informatique)">entier</a> et <a href="Virgule_flottante" title="Virgule flottante">flottant</a>), une table ou une <a href="Fonction_(informatique)" class="mw-redirect" title="Fonction (informatique)">fonction</a>. Il existe aussi d'autres types comme <code>userdata</code> ou <code>thread</code>, moins souvent rencontrés. Le type <code>userdata</code> correspond à un objet <a href="C_(langage)" title="C (langage)">C</a>/<a href="C%2B%2B" title="C++">C++</a> défini par l'utilisateur : il est donc possible de créer une <a href="Type_compos%C3%A9" class="mw-redirect" title="Type composé">structure C</a> ou une <a href="Classe_(informatique)" title="Classe (informatique)">classe C++</a>, et d'utiliser des objets de ce type dans un script Lua après avoir attaché à cet objet une métatable qui se charge d'appeler les fonctions C/C++ appropriées. On pourrait donc imaginer, par exemple, créer les classes métier de base d'un programme en C++, et coder l'application elle-même en Lua, ce qui accélérerait son développement grâce aux outils de <a href="Langage_de_haut_niveau" class="mw-redirect" title="Langage de haut niveau">haut niveau</a> fournis par le langage.
</p><p>Une variable non définie a la valeur <code>nil</code>. Affecter <code>nil</code> à une variable revient à la supprimer.
</p><p>En interne on peut aussi rencontrer des <code>proto</code>, une sorte de prototype de fonction: le <a href="Bytecode" title="Bytecode">bytecode</a> de cette fonction est chargé mais ce dernier n'a pas encore été exécuté. On rencontre les <code>proto</code> quand un fichier est chargé (compilé) mais pas exécuté ou bien avec des <a href="Fermeture_(informatique)" title="Fermeture (informatique)">closures</a>.
</p><p>Par défaut, une variable déclarée est globale à tout l'environnement d'exécution, sauf si elle est précédée du mot-clef <code>local</code>.
</p>
<div class="mw-heading mw-heading3"><h3 id="Les_chaînes"><span id="Les_cha.C3.AEnes"></span>Les chaînes</h3></div>
<p>Les chaînes de caractères sont délimitées par des guillemets simples (<code>'</code>) ou doubles (<code>"</code>), voire par des délimiteurs littéraux <code>[[</code> «de niveau n» où n est un certain nombre de signes =. Une chaîne délimitée ainsi ne s’arrête qu’au délimiteur fermant de même niveau.
</p>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nv">a</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"a</span><span class="se">\t</span><span class="s2">bc"</span><span class="w"> </span><span class="c1">-- Traduit \t en tabulation</span>
<span class="nv">b</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s1">'a</span><span class="se">\t</span><span class="s1">bc"</span><span class="se">\'</span><span class="s1">'</span><span class="w"> </span><span class="c1">-- Traduit \t en tabulation et \' en guillemet littéral.</span>
<span class="nv">c</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">[[...]]</span><span class="w"> </span><span class="c1">-- Multiligne, n’interprète aucune séquence \</span>
<span class="nv">d</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">[=[ ... ]=]</span><span class="w"> </span><span class="c1">-- Multiligne, peut contenir des [[, des -- etc.</span>
<span class="nv">e</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">[==[ ... ]==]</span><span class="w"> </span><span class="c1">-- Multiligne, peut contenir des [=[, des [[, des --, etc.</span>
</pre></div>
<p>L'opérateur de <a href="Concat%C3%A9nation" title="Concaténation">concaténation</a> de chaînes se représente par deux points (<code>..</code>).
</p>
<div class="mw-heading mw-heading3"><h3 id="Les_fonctions">Les fonctions</h3></div>
<p>Les <a href="Fonction_(informatique)" class="mw-redirect" title="Fonction (informatique)">fonctions</a> sont considérées comme des <a href="Variable_(informatique)" title="Variable (informatique)">variables</a>. On peut donc en créer dans d'autres fonctions, en passer comme paramètre ou comme valeur de retour d'une autre fonction, ou en mettre comme clé ou comme valeur dans une table.
</p><p>En Lua, une fonction peut recevoir un nombre quelconque de paramètres, et renvoyer un nombre quelconque de valeurs.
</p>
<div class="mw-heading mw-heading4"><h4 id="Déclarer_une_fonction"><span id="D.C3.A9clarer_une_fonction"></span>Déclarer une fonction</h4></div>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kr">function</span><span class="w"> </span><span class="nf">mafonction</span><span class="p">(</span><span class="nv">arg1</span><span class="p">,</span><span class="w"> </span><span class="nv">arg2</span><span class="p">,</span><span class="w"> </span><span class="p">...)</span>
<span class="w"> </span><span class="c1">-- code</span>
<span class="w"> </span><span class="kr">return</span><span class="w"> </span><span class="nv">résultat1</span><span class="p">,</span><span class="w"> </span><span class="nv">résultat2</span>
<span class="kr">end</span>
</pre></div><p> ou
</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nv">mafonction</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kr">function</span><span class="w"> </span><span class="p">(</span><span class="nv">arg1</span><span class="p">,</span><span class="w"> </span><span class="nv">arg2</span><span class="p">,</span><span class="w"> </span><span class="p">...)</span>
<span class="w"> </span><span class="c1">-- code</span>
<span class="w"> </span><span class="kr">return</span><span class="w"> </span><span class="nv">résultat1</span><span class="p">,</span><span class="w"> </span><span class="nv">résultat2</span>
<span class="kr">end</span>
</pre></div><p>Le return doit être la dernière instruction avant end. Si nécessaire, on le met dans un bloc inconditionnel.
</p><div class="mw-heading mw-heading4"><h4 id="Appeler_une_fonction">Appeler une fonction</h4></div>
<p>Les paramètres non-précisés à l’appel sont considérés comme <code>nil</code>.
Les valeurs renvoyées en trop sont ignorées.
</p>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nv">res1</span><span class="p">,</span><span class="w"> </span><span class="nv">res2</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">mafonction</span><span class="p">(</span><span class="nv">var</span><span class="p">)</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Les_tables,_métatables"><span id="Les_tables.2C_m.C3.A9tatables"></span>Les tables, métatables</h3></div>
<p>En Lua, la structure stocke des valeurs indexées par une clé (comme en <a href="PHP" title="PHP">PHP</a> par exemple). C’est la structure centrale du langage pour représenter tous les objets complexes.
</p>
<div class="mw-heading mw-heading4"><h4 id="Index_et_valeurs">Index et valeurs</h4></div>
<p>Une table peut, entre autres, être utilisée comme :
</p>
<ul><li>Une <a href="Liste_(informatique)" title="Liste (informatique)">liste</a> (par exemple la syntaxe {a,b,c,…} crée une liste débutant à l’index 1). L’opérateur <code>#</code> donne alors la longueur de la liste.</li>
<li>Une <a href="Table_de_hachage" title="Table de hachage">hashtable</a> (pouvant faire office de <a href="Type_compos%C3%A9" class="mw-redirect" title="Type composé">structure</a>), qui peut prendre en clé et en valeur tout type de variable (sauf <code>nil</code>).</li></ul>
<p>Les index et les valeurs peuvent être de tout type (l’opérateur <code>#</code> fonctionne toujours mais n’a vraiment de sens que pour les listes)
</p><p>Par convention, on parcourt une liste avec l'itérateur <code>ipairs</code> et une hashtable avec l'itérateur <code>pairs</code>.
</p><p>La clé <code>nil</code> est interdite. Affecter <code>nil</code> à un index est permis mais revient à le supprimer. Ainsi <code>a={nil,"x",nil,"y"}</code> équivaut à <code>a={[2]="x",[4]="y"}</code>. L’opérateur de longueur <code>#</code> n’a alors plus de sens, l’itérateur <code>pairs</code> saute les <code>nil</code>, et l’itérateur <code>ipairs</code> s’arrête au premier <code>nil</code>.
</p>
<div class="mw-heading mw-heading4"><h4 id="Métatables_et_objets"><span id="M.C3.A9tatables_et_objets"></span>Métatables et objets</h4></div>
<p>Les tables facilitent la programmation dans un style objet, notamment grâce à deux sucres syntaxiques:
</p>
<ul><li><code>objet.clef</code> équivaut à <code>objet["clef"]</code></li>
<li><code>objet:f()</code> passe à <code>objet.f()</code> un argument caché <code>self=objet</code></li></ul>
<p>Quant aux métatables, introduites <sup id="cite_ref-3" class="reference"><a href="#cite_note-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup> dans Lua 2.1, ce sont des tables que l’on associe à un objet, pour introduire une sorte d’<a href="H%C3%A9ritage_(informatique)" title="Héritage (informatique)">héritage</a>. En effet, si un objet <code>x</code> est associé à la métatable <code>m</code>, et si <code>x[c]</code> n’existe pas, Lua cherche <code>m[c]</code> à la place.
</p><p>Les métatables permettent également une sorte de <a href="Surcharge_des_op%C3%A9rateurs" class="mw-redirect" title="Surcharge des opérateurs">surcharge des opérateurs</a>, car Lua y cherche les fonctions <code>__add()</code>, <code>__sub()</code>, <code>__call()</code>, <code>__index()</code> … pour exécuter les opérations <code>+</code>, <code>-</code>, <code>()</code>, <code>[]</code>….
</p><p>L’objet Vector ci-dessous illustre ces notions avec un constructeur, une méthode, et deux opérateurs redéfinis:
</p>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">Vector</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{}</span>
<span class="nv">Vector</span><span class="p">.</span><span class="py">__index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">Vector</span><span class="w"> </span><span class="c1">-- Où chercher les index absents</span>
<span class="kr">function</span><span class="w"> </span><span class="nc">Vector</span><span class="p">:</span><span class="nf">new</span><span class="p">(</span><span class="nv">x</span><span class="p">,</span><span class="w"> </span><span class="nv">y</span><span class="p">,</span><span class="w"> </span><span class="nv">z</span><span class="p">)</span><span class="w"> </span><span class="c1">-- Constructeur</span>
<span class="w"> </span><span class="c1">-- Le ":" passe "self" en premier, qui référence "Vector"</span>
<span class="w"> </span><span class="kr">return</span><span class="w"> </span><span class="nb">setmetatable</span><span class="p">({</span><span class="nv">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">x</span><span class="p">,</span><span class="w"> </span><span class="nv">y</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">y</span><span class="p">,</span><span class="w"> </span><span class="nv">z</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">z</span><span class="p">},</span><span class="w"> </span><span class="nv">self</span><span class="p">)</span>
<span class="kr">end</span>
<span class="kr">function</span><span class="w"> </span><span class="nc">Vector</span><span class="p">:</span><span class="nf">magnitude</span><span class="p">()</span><span class="w"> </span><span class="c1">-- Exemple de méthode</span>
<span class="w"> </span><span class="kr">return</span><span class="w"> </span><span class="nb">math.sqrt</span><span class="p">(</span><span class="nv">self</span><span class="p">.</span><span class="py">x</span><span class="o">^</span><span class="mi">2</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">self</span><span class="p">.</span><span class="py">y</span><span class="o">^</span><span class="mi">2</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">self</span><span class="p">.</span><span class="py">z</span><span class="o">^</span><span class="mi">2</span><span class="p">)</span><span class="w"> </span><span class="c1">-- "self" est passé grâce à ":"</span>
<span class="kr">end</span>
<span class="kr">function</span><span class="w"> </span><span class="nc">Vector</span><span class="p">.</span><span class="nf">__add</span><span class="p">(</span><span class="nv">a</span><span class="p">,</span><span class="nv">b</span><span class="p">)</span><span class="w"> </span><span class="c1">-- Définit "+"</span>
<span class="w"> </span><span class="kr">return</span><span class="w"> </span><span class="nv">Vector</span><span class="p">:</span><span class="nf">new</span><span class="p">(</span><span class="nv">a</span><span class="p">.</span><span class="py">x</span><span class="o">+</span><span class="nv">b</span><span class="p">.</span><span class="py">x</span><span class="p">,</span><span class="w"> </span><span class="nv">a</span><span class="p">.</span><span class="py">y</span><span class="o">+</span><span class="nv">b</span><span class="p">.</span><span class="py">y</span><span class="p">,</span><span class="nv">a</span><span class="p">.</span><span class="py">z</span><span class="o">+</span><span class="nv">b</span><span class="p">.</span><span class="py">z</span><span class="p">)</span>
<span class="kr">end</span>
<span class="kr">function</span><span class="w"> </span><span class="nc">Vector</span><span class="p">.</span><span class="nf">__unm</span><span class="p">(</span><span class="nv">a</span><span class="p">)</span><span class="w"> </span><span class="c1">-- Définit la négation "-"</span>
<span class="w"> </span><span class="kr">return</span><span class="w"> </span><span class="nv">Vector</span><span class="p">:</span><span class="nf">new</span><span class="p">(</span><span class="o">-</span><span class="nv">a</span><span class="p">.</span><span class="py">x</span><span class="p">,</span><span class="o">-</span><span class="nv">a</span><span class="p">.</span><span class="py">y</span><span class="p">,</span><span class="o">-</span><span class="nv">a</span><span class="p">.</span><span class="py">z</span><span class="p">)</span>
<span class="kr">end</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">v</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">Vector</span><span class="p">:</span><span class="nf">new</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">)</span><span class="w"> </span><span class="c1">-- Crée un vector</span>
<span class="nb">print</span><span class="p">(</span><span class="nv">v</span><span class="p">:</span><span class="nf">magnitude</span><span class="p">())</span><span class="w"> </span><span class="c1">-- Appel de méthode (sortie: 1)</span>
<span class="nb">print</span><span class="p">(</span><span class="nv">v</span><span class="p">.</span><span class="py">x</span><span class="p">,</span><span class="w"> </span><span class="nv">v</span><span class="p">.</span><span class="py">y</span><span class="p">,</span><span class="w"> </span><span class="nv">v</span><span class="p">.</span><span class="py">z</span><span class="p">)</span><span class="w"> </span><span class="c1">-- Accès aux membres (sortie: 0 1 0)</span>
<span class="nv">w</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">-</span><span class="p">(</span><span class="nv">v</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">v</span><span class="p">)</span><span class="w"> </span><span class="c1">-- + et - définis par __add() et __unm()</span>
<span class="nb">print</span><span class="p">(</span><span class="nv">w</span><span class="p">.</span><span class="py">x</span><span class="p">,</span><span class="nv">w</span><span class="p">.</span><span class="py">y</span><span class="p">,</span><span class="nv">w</span><span class="p">.</span><span class="py">z</span><span class="p">)</span><span class="w"> </span><span class="c1">-- Résultat (sortie: 0 -2 0)</span>
</pre></div>
<div class="mw-heading mw-heading4"><h4 id="Déclaration_de_table"><span id="D.C3.A9claration_de_table"></span>Déclaration de table</h4></div>
<p>Pour créer une table à indices numériques consécutifs (démarrant à 1):
</p>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nv">a</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="mi">5</span><span class="p">,</span><span class="w"> </span><span class="s2">"foo"</span><span class="p">,</span><span class="w"> </span><span class="s">[[C:\Lua\Lua.exe]]</span><span class="p">,</span><span class="w"> </span><span class="s1">'bar'</span><span class="p">,</span><span class="w"> </span><span class="mi">42</span><span class="w"> </span><span class="p">}</span>
</pre></div>
<p>On peut donner explicitement les indices de la table à créer, entre crochets. Les indices chaînes semblables à un nom de variable peuvent se passer de guillemets et de crochets :
</p>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nv">a</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="nv">d</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">5</span><span class="p">,</span><span class="w"> </span><span class="p">[</span><span class="mi">12</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"foo"</span><span class="p">,</span><span class="w"> </span><span class="p">[</span><span class="s1">'chaîne avec espace'</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">true</span><span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="c1">-- comme ["d"]=5</span>
</pre></div>
<p>Dans une assignation, la valeur est copiée si c’est un nombre, une chaîne ou un booléen. Sinon seule la référence est copiée. En particulier, si la variable a est une table et si on assigne a à la variable b, alors toute modification dans la table a est visible dans b, et vice-versa :
</p>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">a</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="mi">1</span><span class="p">,</span><span class="s2">"b"</span><span class="p">,</span><span class="mi">3</span><span class="p">}</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">b</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">a</span>
<span class="nv">a</span><span class="p">.</span><span class="py">foo</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"bar"</span>
<span class="nb">print</span><span class="p">(</span><span class="nv">b</span><span class="p">.</span><span class="py">foo</span><span class="p">)</span><span class="w"> </span><span class="c1">-- bar</span>
<span class="c1">-- b et a ont la même référence</span>
</pre></div>
<p>L’exemple qui suit est une table stockant des variables complexes : autres tables, fonctions, références croisées…
</p><p>De même que ci-dessus, si un indice n’est ni un nombre, ni une chaîne de caractères, ni un booléen, c’est une référence vers la variable concernée :
</p>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="w"> </span><span class="nv">fonction</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kr">function</span><span class="w"> </span><span class="p">(</span><span class="nv">a</span><span class="p">,</span><span class="w"> </span><span class="nv">b</span><span class="p">)</span><span class="w"> </span><span class="kr">return</span><span class="w"> </span><span class="p">(</span><span class="nv">a</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nv">b</span><span class="p">)</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="nv">a</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="nv">b</span><span class="w"> </span><span class="kr">end</span>
<span class="nv">t</span><span class="w"> </span><span class="o">=</span>
<span class="p">{</span>
<span class="w"> </span><span class="nv">b</span><span class="w"> </span><span class="o">=</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="c1">-- Fonction comme clé</span>
<span class="w"> </span><span class="p">[</span><span class="nv">fonction</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s1">'Fonction !'</span><span class="p">,</span><span class="w"> </span><span class="c1">-- la référence à fonction sert de clé</span>
<span class="w"> </span><span class="p">[</span><span class="mi">5</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">42</span><span class="p">,</span><span class="w"> </span><span class="c1">-- Index numérique</span>
<span class="w"> </span><span class="c1">-- Index chaîne simple (c.-à-d. la syntaxe d'une variable)</span>
<span class="w"> </span><span class="nv">ls</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">[[Valeur</span>
<span class="s">Multiligne]]</span><span class="w"> </span><span class="p">,</span>
<span class="w"> </span><span class="c1">-- Index chaîne quelconque</span>
<span class="w"> </span><span class="p">[</span><span class="s1">'Expression rationnelle'</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">[[(?:\d{1,3}\.){3}\d{1,3}]]</span><span class="p">,</span>
<span class="w"> </span><span class="p">[</span><span class="w"> </span><span class="s">[[C:\Lua\Lua.exe]]</span><span class="w"> </span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">true</span><span class="p">,</span>
<span class="w"> </span><span class="p">},</span>
<span class="w"> </span><span class="nv">f</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kr">function</span><span class="w"> </span><span class="p">()</span><span class="w"> </span><span class="kr">return</span><span class="w"> </span><span class="nb">math.random</span><span class="p">(</span><span class="mi">100</span><span class="p">)</span><span class="w"> </span><span class="kr">end</span><span class="p">,</span><span class="w"> </span><span class="c1">-- clé "f" référençant une fonction anonyme.</span>
<span class="w"> </span><span class="nv">ff</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">fonction</span><span class="p">,</span><span class="w"> </span><span class="c1">-- clé "ff" référençant la fonction globale "fonction"</span>
<span class="w"> </span><span class="c1">-- Référence de table anonyme comme clé: valeur difficilement accessible</span>
<span class="w"> </span><span class="p">[</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="s1">'a'</span><span class="p">,</span><span class="w"> </span><span class="s1">'b'</span><span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="s2">"aa"</span><span class="p">,</span><span class="w"> </span><span class="s2">"bb"</span><span class="w"> </span><span class="p">},</span><span class="w"> </span><span class="c1">-- (i)</span>
<span class="p">}</span>
<span class="c1">-- Référence dans la table</span>
<span class="nv">t</span><span class="p">.</span><span class="py">self</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">t</span><span class="w"> </span><span class="c1">-- Référence à soi-même</span>
<span class="nb">print</span><span class="p">(</span><span class="nv">t</span><span class="p">[</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="s1">'a'</span><span class="p">,</span><span class="s1">'b'</span><span class="p">}</span><span class="w"> </span><span class="p">])</span><span class="w"> </span><span class="c1">-- nil car la référence de la nouvelle table { 'a','b' } </span>
<span class="w"> </span><span class="c1">-- n'est pas celle de la table { 'a','b' } qui sert de clé en (i)</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Boucles,_blocs_et_conditions"><span id="Boucles.2C_blocs_et_conditions"></span>Boucles, blocs et conditions</h2></div>
<div class="mw-heading mw-heading3"><h3 id="Condition">Condition</h3></div>
<p>La structure <code>if ... then ... elseif ... else ... end</code> est semblable à celle de la plupart des langages
</p>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kr">if</span><span class="w"> </span><span class="nv">condition1</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="nv">condition2</span><span class="w"> </span><span class="kr">then</span>
<span class="w"> </span><span class="c1">-- si les conditions 1 et 2 sont vraies</span>
<span class="kr">elseif</span><span class="w"> </span><span class="nv">condition1</span><span class="w"> </span><span class="kr">then</span>
<span class="w"> </span><span class="c1">-- si la condition 1 est vraie et la condition 2 est fausse</span>
<span class="kr">elseif</span><span class="w"> </span><span class="nv">condition2</span><span class="w"> </span><span class="kr">then</span>
<span class="w"> </span><span class="c1">-- si la condition 2 est vraie et la condition 1 est fausse</span>
<span class="kr">else</span>
<span class="w"> </span><span class="c1">-- si les deux conditions sont fausses</span>
<span class="kr">end</span>
</pre></div>
<p>Les opérateurs logiques sont <code>and</code>, <code>or</code> et <code>not</code>.
</p><p>Les booléens sont <code>true</code> et <code>false</code>, mais les expressions conditionnelles concernent tous les types:
une condition est fausse si elle vaut <code>nil</code> ou <code>false</code>, et vraie sinon.
</p>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kr">for</span><span class="w"> </span><span class="nv">i</span><span class="p">,</span><span class="nv">v</span><span class="w"> </span><span class="kr">in</span><span class="w"> </span><span class="nb">ipairs</span><span class="p">({</span><span class="kc">true</span><span class="p">,</span><span class="w"> </span><span class="kc">false</span><span class="p">,</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="s2">""</span><span class="p">,</span><span class="w"> </span><span class="s2">"0"</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="s2">"true"</span><span class="p">,</span><span class="w"> </span><span class="s2">"false"</span><span class="p">})</span><span class="w"> </span><span class="kr">do</span>
<span class="w"> </span><span class="kr">if</span><span class="w"> </span><span class="p">(</span><span class="nv">v</span><span class="p">)</span><span class="w"> </span><span class="kr">then</span><span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="nv">v</span><span class="p">),</span><span class="w"> </span><span class="nv">v</span><span class="p">,</span><span class="w"> </span><span class="s2">" est vrai"</span><span class="p">)</span><span class="w"> </span><span class="kr">else</span><span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="nv">v</span><span class="p">),</span><span class="w"> </span><span class="nv">v</span><span class="p">,</span><span class="w"> </span><span class="s2">" est faux"</span><span class="p">)</span><span class="w"> </span><span class="kr">end</span>
<span class="w"> </span><span class="c1">-- boolean true est vrai</span>
<span class="w"> </span><span class="c1">-- boolean false est faux</span>
<span class="w"> </span><span class="c1">-- number 1 est vrai</span>
<span class="w"> </span><span class="c1">-- string est vrai -- Pas comme dans awk</span>
<span class="w"> </span><span class="c1">-- string 0 est vrai --</span>
<span class="w"> </span><span class="c1">-- number 0 est vrai -- Eh oui! pas comme en C</span>
<span class="w"> </span><span class="c1">-- string true est vrai</span>
<span class="w"> </span><span class="c1">-- string false est vrai -- "false" est une string, pas le booléen false</span>
<span class="kr">end</span>
</pre></div>
<p>Les opérateurs logiques <code>and</code> et <code>or</code> appliquent une logique de "court-circuit", en renvoyant le premier de leurs opérandes qui suffit à savoir si la formule est vraie ou fausse.
</p>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="c1">-- Illustration du court-circuit pour «and» et «or»</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"un"</span><span class="w"> </span><span class="ow">or</span><span class="w"> </span><span class="s2">"deux"</span><span class="w"> </span><span class="ow">or</span><span class="w"> </span><span class="s2">"trois"</span><span class="p">)</span><span class="w"> </span><span class="c1">-- "un" : «or» arrête au premier terme vrai et le renvoie</span>
<span class="nb">print</span><span class="p">(</span><span class="kc">nil</span><span class="w"> </span><span class="ow">or</span><span class="w"> </span><span class="kc">false</span><span class="w"> </span><span class="ow">or</span><span class="w"> </span><span class="s2">"dernier"</span><span class="p">)</span><span class="w"> </span><span class="c1">-- "dernier" ... sinon il donne le dernier terme.</span>
<span class="nb">print</span><span class="w"> </span><span class="p">(</span><span class="s2">"un"</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="kc">nil</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="s2">"trois"</span><span class="p">)</span><span class="w"> </span><span class="c1">-- "nil" : «and» arrête au premier terme faux et le renvoie</span>
<span class="nb">print</span><span class="w"> </span><span class="p">(</span><span class="s2">"un"</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="s2">"deux"</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="s2">"trois"</span><span class="p">)</span><span class="w"> </span><span class="c1">-- "trois" : ... sinon il donne le dernier terme.</span>
<span class="c1">-- Avec des booléens cette logique équivaut aux formules classiques</span>
<span class="nb">print</span><span class="p">(</span><span class="kc">false</span><span class="w"> </span><span class="ow">or</span><span class="w"> </span><span class="kc">true</span><span class="w"> </span><span class="ow">or</span><span class="w"> </span><span class="kc">false</span><span class="p">)</span><span class="w"> </span><span class="c1">-- true</span>
<span class="nb">print</span><span class="p">(</span><span class="kc">true</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="kc">true</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="kc">false</span><span class="p">)</span><span class="w"> </span><span class="c1">-- false</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Boucles">Boucles</h3></div><p>
Les structures <code>while</code> et <code>repeat</code> rebouclent tant qu’une condition est vraie. La boucle <code>repeat</code> exécute au moins une fois son corps car elle teste sa condition à la fin.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kr">repeat</span>
<span class="w"> </span><span class="c1">-- code</span>
<span class="kr">until</span><span class="w"> </span><span class="nv">condition</span>
</pre></div>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kr">while</span><span class="w"> </span><span class="nv">condition</span><span class="w"> </span><span class="kr">do</span>
<span class="w"> </span><span class="c1">-- code</span>
<span class="kr">end</span>
</pre></div><p>
Une boucle <code>for</code> affecte successivement des valeurs données par un départ, une arrivée et un incrément, ou par un énumérateur.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kr">for</span><span class="w"> </span><span class="nv">var</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">start</span><span class="p">,</span><span class="w"> </span><span class="nv">valend</span><span class="p">,</span><span class="w"> </span><span class="nv">step</span><span class="w"> </span><span class="kr">do</span>
<span class="w"> </span><span class="c1">-- code</span>
<span class="kr">end</span>
</pre></div>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kr">for</span><span class="w"> </span><span class="nv">var_1</span><span class="p">,</span><span class="w"> </span><span class="p">...,</span><span class="w"> </span><span class="nv">var_n</span><span class="w"> </span><span class="kr">in</span><span class="w"> </span><span class="nv">explist</span><span class="w"> </span><span class="kr">do</span>
<span class="w"> </span><span class="c1">-- code</span>
<span class="w"> </span><span class="kr">if</span><span class="w"> </span><span class="nv">condition_arret</span><span class="w"> </span><span class="kr">then</span>
<span class="w"> </span><span class="c1">-- autre code</span>
<span class="w"> </span><span class="kr">break</span><span class="w"> </span><span class="c1">-- doit toujours être suivi d’un "end"</span>
<span class="w"> </span><span class="kr">end</span>
<span class="w"> </span><span class="c1">-- code</span>
<span class="kr">end</span>
</pre></div><p>Le dernier exemple montre une instruction <code>break</code> pour quitter la boucle. Elle doit toujours figurer avant un <code>end</code>, ce qui demande parfois de créer un bloc inconditionnel.
</p><div class="mw-heading mw-heading3"><h3 id="Blocs_inconditionnels">Blocs inconditionnels</h3></div>
<p>Les blocs inconditionnels servent par exemple à limiter la visibilité des variables locales :
</p>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kr">do</span>
<span class="w"> </span><span class="kd">local</span><span class="w"> </span><span class="nv">mavariable</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"chaîne"</span><span class="w"> </span><span class="c1">-- déclaration de variable, optionnel</span>
<span class="w"> </span><span class="c1">-- code utilisant mavariable</span>
<span class="kr">end</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Les_fonctions_standard">Les fonctions standard</h2></div>
<div class="mw-heading mw-heading3"><h3 id="Les_fonctions_mathématiques"><span id="Les_fonctions_math.C3.A9matiques"></span>Les fonctions mathématiques</h3></div><p>
La valeur math.pi est le nombre pi.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="nb">math.pi</span><span class="p">)</span><span class="w"> </span><span class="c1">--> Affiche dans la console la valeur de pi (3.1415926535898)</span>
</pre></div><p>La fonction math.min(liste) retourne le plus petit nombre contenu dans une liste</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="nb">math.min</span><span class="p">(</span><span class="mi">6</span><span class="p">,</span><span class="w"> </span><span class="mi">4</span><span class="p">,</span><span class="w"> </span><span class="mi">2</span><span class="p">,</span><span class="w"> </span><span class="mi">9</span><span class="p">,</span><span class="w"> </span><span class="mi">1</span><span class="p">))</span><span class="w"> </span><span class="c1">--> Affiche 1 dans la console étant donné que 1 est le plus petit nombre de la liste.</span>
</pre></div><p>La fonction math.max(liste) retourne le plus grand nombre contenu dans une liste</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="nb">math.max</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span><span class="w"> </span><span class="mi">6</span><span class="p">,</span><span class="w"> </span><span class="mi">7</span><span class="p">,</span><span class="w"> </span><span class="mi">9</span><span class="p">,</span><span class="w"> </span><span class="mi">1</span><span class="p">))</span><span class="w"> </span><span class="c1">--> Affiche 9 dans la console étant donné que ce nombre est le plus grand de sa liste.</span>
</pre></div><p>La fonction math.floor(x) retourne la partie entière de x.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="nb">math.floor</span><span class="p">(</span><span class="mf">1.5</span><span class="p">))</span><span class="w"> </span><span class="c1">--> Retourne dans la console le nombre 1</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">math.floor</span><span class="p">(</span><span class="mf">1.5</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mf">0.5</span><span class="p">))</span><span class="w"> </span><span class="c1">--> Retourne dans la console le nombre 2</span>
</pre></div><p>La fonction math.abs(x) retourne la <a href="Valeur_absolue" title="Valeur absolue">valeur absolue</a> de x.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="nb">math.abs</span><span class="p">(</span><span class="o">-</span><span class="mi">100</span><span class="p">))</span><span class="w"> </span><span class="c1">--> Retourne dans la console le nombre 100.</span>
</pre></div><p>La fonction math.pow(x, y) retourne x à la puissance de y. On peut aussi utiliser l'expression x^y</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="nb">math.pow</span><span class="p">(</span><span class="mi">6</span><span class="p">,</span><span class="w"> </span><span class="mi">8</span><span class="p">))</span><span class="w"> </span><span class="c1">--> Retourne dans la console le nombre 1679616.</span>
<span class="c1">-- On peut également utiliser:</span>
<span class="nb">print</span><span class="p">(</span><span class="mi">6</span><span class="o">^</span><span class="mi">8</span><span class="p">)</span>
</pre></div><p>La fonction math.random(x, y) retourne un nombre aléatoire entre la valeur x et la valeur y.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">y</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">10</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">math.random</span><span class="p">(</span><span class="nv">x</span><span class="p">,</span><span class="w"> </span><span class="nv">y</span><span class="p">))</span><span class="w"> </span><span class="c1">--> Retourne dans la console un nombre entier aléatoire entre 1 et 10.</span>
</pre></div><p>La fonction math.sqrt(x) retourne la racine carrée de x.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">6</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">math.sqrt</span><span class="p">(</span><span class="nv">x</span><span class="p">))</span><span class="w"> </span><span class="c1">--> Retourne la racine carrée de x(6) donc 2.4494897427832.</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Les_fonctions_os">Les fonctions os</h3></div><p>
La fonction os.time() retourne le nombre de secondes entre le <time class="nowrap" datetime="1970-01-01" data-sort-value="1970-01-01"><abbr class="abbr" title="premier">1<sup>er</sup></abbr> janvier 1970</time> à 00:00 et la seconde à laquelle vous appelez la fonction.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="nb">os.time</span><span class="p">())</span>
</pre></div><p>La fonction os.date() retourne le jour, le mois, le numéro du mois, l'heure, les minutes, les secondes et l'année à laquelle vous êtes quand vous appelez cette "fonction"</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="nb">os.date</span><span class="p">())</span><span class="w"> </span><span class="c1">--> Retourne Thu Jul 1 14:52:59 2021</span>
</pre></div><p>La fonction os.clock() retourne le temps écoulé en seconde depuis que Lua a été lancé.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="nb">os.clock</span><span class="p">())</span><span class="w"> </span><span class="c1">--> Retourne dans la console 853312.913685</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="La_fonction_type">La fonction type</h3></div><p>
La fonction type(x) donne le type de x sous forme de chaîne.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">a</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"Bonjour"</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">b</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">5</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">c</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">true</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">d</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="nv">a</span><span class="p">))</span><span class="w"> </span><span class="c1">--> Affiche "string" car la variable est de type string.</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="nv">b</span><span class="p">))</span><span class="w"> </span><span class="c1">--> Affiche "number" car la variable est de type number.</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="nv">c</span><span class="p">))</span><span class="w"> </span><span class="c1">--> Affiche "boolean" car la variable est une valeur booléene</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="nb">print</span><span class="p">))</span><span class="w"> </span><span class="c1">--> Affiche "function" car print est une fonction.</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="nv">d</span><span class="p">))</span><span class="w"> </span><span class="c1">--> Affiche "nil" car la variable d ne contient pas de valeur.</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Les_fonctions_table">Les fonctions table</h3></div>
<p>En lua, il existe 9 fonctions table.
</p><p>
La fonction <i><b>table.insert(x, y, z)</b></i> insère une valeur y dans un tableau x. On peut lui indiquer la position d’insertion avec un argument z. Si z n'est pas donné, la valeur est mise en dernière position de la table.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">tableau</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="s2">"je"</span><span class="p">,</span><span class="w"> </span><span class="s2">"suis"</span><span class="p">,</span><span class="w"> </span><span class="s2">"un"</span><span class="p">,</span><span class="w"> </span><span class="s2">"utilisateur"</span><span class="p">,</span><span class="w"> </span><span class="s2">"du"</span><span class="p">}</span>
<span class="nb">table.insert</span><span class="p">(</span><span class="nv">tableau</span><span class="p">,</span><span class="w"> </span><span class="s2">"wiki"</span><span class="p">)</span><span class="w"> </span><span class="c1">--> Insert dans la variable tableau enla valeur wiki. Le troisième argument pour donner la position n'est pas donné donc la valeur se positionnera en dernière place du tableau.</span>
</pre></div><p>La fonction <i><b>table.remove(x, y)</b></i> retire du tableau x la valeur qui se trouve en position y.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">tableau</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="s2">"je"</span><span class="p">,</span><span class="w"> </span><span class="s2">"suis"</span><span class="p">,</span><span class="w"> </span><span class="s2">"un"</span><span class="p">,</span><span class="w"> </span><span class="s2">"faux"</span><span class="p">,</span><span class="w"> </span><span class="s2">"utilisateur"</span><span class="p">}</span>
<span class="nb">table.remove</span><span class="p">(</span><span class="nv">tableau</span><span class="p">,</span><span class="w"> </span><span class="mi">4</span><span class="p">)</span><span class="w"> </span><span class="c1">--> Retire la valeur "faux" du tableau qui était en {{4e|position}}.</span>
<span class="c1">-- Il faut connaître la position de la valeur à retirer. Sinon, on peut utiliser pairs() dans une boucle.</span>
</pre></div><p>La fonction <i><b>table.sort(x)</b></i> permet de trier et modifier la position des éléments du tableau x.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">tableau</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="mi">6</span><span class="p">,</span><span class="w"> </span><span class="mi">4</span><span class="p">,</span><span class="w"> </span><span class="mi">5</span><span class="p">,</span><span class="w"> </span><span class="mi">3</span><span class="p">,</span><span class="w"> </span><span class="mi">2</span><span class="p">,</span><span class="w"> </span><span class="mi">1</span><span class="p">}</span>
<span class="nb">table.sort</span><span class="p">(</span><span class="nv">tableau</span><span class="p">)</span><span class="w"> </span><span class="c1">--> Va venir trier les valeurs du tableau et le modifier en {1, 2, 3, 4, 5, 6}</span>
</pre></div><p>La fonction <i><b>table.concat(x, y)</b></i> concatène les valeurs d'un tableau pour former une chaine de caractères. Le y, facultatif, sert à séparer les valeurs.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">tableau</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="s2">"un"</span><span class="p">,</span><span class="w"> </span><span class="s2">"renard"</span><span class="p">,</span><span class="w"> </span><span class="s2">"caché"</span><span class="p">,</span><span class="w"> </span><span class="s2">"dans"</span><span class="p">,</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="s2">"arbre"</span><span class="p">}</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">concatTableau</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">table.concat</span><span class="p">(</span><span class="nv">tableau</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="nv">concatTableau</span><span class="p">)</span><span class="w"> </span><span class="c1">--> Retourne dans la console la valeur unrenardcachédans1arbre</span>
</pre></div><p>Voici un exemple d’utilisation du séparateur y:.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">tableau</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="s2">"un"</span><span class="p">,</span><span class="w"> </span><span class="s2">"renard"</span><span class="p">,</span><span class="w"> </span><span class="s2">"caché"</span><span class="p">,</span><span class="w"> </span><span class="s2">"dans"</span><span class="p">,</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="s2">"arbre"</span><span class="p">}</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">concatTableau</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">table.concat</span><span class="p">(</span><span class="nv">tableau</span><span class="p">,</span><span class="w"> </span><span class="s2">" | "</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="nv">concatTableau</span><span class="p">)</span><span class="w"> </span><span class="c1">--> affiche: un | renard | caché | dans | 1 | arbre. L'argument " | " a été ajouté entre chaque valeur transformée.</span>
</pre></div><p>Les fonction <i><b>table.foreach(x, z)</b></i> et <i><b>table.foreachi(x, y)</b></i> sont obsolètes depuis la version 5.1 de lua et doivent être remplacées par <b>pairs()</b> et <b>ipairs()</b>. Voir ci-dessous.
La fonction <i><b>table.getn(x)</b></i> donne la taille d'un tableau x.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">tableau</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="s2">"un"</span><span class="p">,</span><span class="w"> </span><span class="s2">"renard"</span><span class="p">,</span><span class="w"> </span><span class="s2">"gentil"</span><span class="p">}</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">longueur</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">table</span><span class="p">.</span><span class="nf">getn</span><span class="p">(</span><span class="nv">tableau</span><span class="p">)</span><span class="w"> </span><span class="c1">-- à remplacer par l’opérateur #tableau depuis lua 5.1</span>
<span class="nb">print</span><span class="p">(</span><span class="nv">longueur</span><span class="p">)</span><span class="w"> </span><span class="c1">--> Retourne dans la console la longueur du tableau "tableau" donc 3.</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Les_fonctions_strings">Les fonctions strings</h3></div>
<p>Les fonctions «string.», au nombre de 15, opèrent sur les variables de type string.
</p><p>
Le <i><b>string.find(x, y)</b></i> recherche des caractères y dans le string x. Il renvoie nil si rien n’est trouvé. Sinon il indique à partir de quel emplacement les caractères recherchés ont été trouvés.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">variable</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"Bonjour, je m'appelle Lua."</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">find</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">string.find</span><span class="p">(</span><span class="nv">variable</span><span class="p">,</span><span class="w"> </span><span class="s2">"our"</span><span class="p">)</span>
<span class="kr">if</span><span class="w"> </span><span class="nv">find</span><span class="w"> </span><span class="kr">then</span><span class="w"> </span><span class="c1">-- Si find ne vaut pas nil, alors la chaîne est trouvée.</span>
<span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="nv">find</span><span class="p">)</span><span class="w"> </span><span class="c1">-- Alors find donne l’index du premier caractère de la chaîne trouvée (ici 5).</span>
<span class="kr">end</span>
</pre></div><p>On peut aussi ajouter un argument z pour commencer la recherche à une certaine position.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">MA_VARIABLE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"Je suis quelqu'un qui suis une autre personne."</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">resultat</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">string.find</span><span class="p">(</span><span class="nv">MA_VARIABLE</span><span class="p">,</span><span class="w"> </span><span class="s2">"is"</span><span class="p">,</span><span class="w"> </span><span class="mi">17</span><span class="p">)</span>
<span class="kr">if</span><span class="w"> </span><span class="nv">resultat</span><span class="w"> </span><span class="kr">then</span><span class="w"> </span><span class="c1">-- Si "is" est trouvé au caractère 17 ou après, alors ...</span>
<span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="nv">resultat</span><span class="p">)</span><span class="w"> </span><span class="c1">-- resultat contient la position du premier caractère trouvé (ici 25) </span>
<span class="kr">end</span>
</pre></div><p>Le <i><b>string.byte(x, y, z)</b></i> renvoie le code numérique des caractères (Code ASCII) de la string x.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">MA_VARIABLE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"Je suis une gentille personne"</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">RESULTAT_ASCII</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">string.byte</span><span class="p">(</span><span class="nv">MA_VARIABLE</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="nv">RESULTAT_ASCII</span><span class="p">)</span><span class="w"> </span><span class="c1">--> Retourne dans la console le résultat de la conversion de la string en code numérique ASCII</span>
</pre></div><p>On peut aussi utiliser l'argument y pour définir un début de conversion ainsi que l'argument z pour définir la fin de conversion (numéro de caractère).</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">MA_VARIABLE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"Je suis une gentille personne"</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">RESULTAT_ASCII</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">string.byte</span><span class="p">(</span><span class="nv">MA_VARIABLE</span><span class="p">,</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="mi">10</span><span class="p">)</span><span class="w"> </span><span class="c1">--> Retourne la conversion du caractère 1 à 10 de la string</span>
<span class="nb">print</span><span class="p">(</span><span class="nv">RESULTAT_ASCII</span><span class="p">)</span><span class="w"> </span><span class="c1">--> Retourne dans la console le résultat de la conversion en ASCII du caractère 1 à 10 de la string.</span>
</pre></div><p>Le <i><b>string.char(x)</b></i> convertit le code numérique x qui est en code ASCII en caractères normaux.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">ASCII_CODE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">74</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">RESULTAT</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">string.char</span><span class="p">(</span><span class="nv">ASCII_CODE</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="nv">RESULTAT</span><span class="p">)</span><span class="w"> </span><span class="c1">--> Retourne dans la console la conversion du code numérique ASCII en caractères numériques (de la variable ASCII_CODE)</span>
</pre></div><p>Le <i><b>string.dump(x)</b></i> convertit la fonction x en une représentation binaire utilisable par la fonction loadString(y).</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kr">function</span><span class="w"> </span><span class="nf">demonstration</span><span class="p">()</span>
<span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"Lancement de la fonction"</span><span class="p">)</span>
<span class="kr">end</span>
<span class="kd">local</span><span class="w"> </span><span class="nv">dumped</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">string.dump</span><span class="p">(</span><span class="nv">demonstration</span><span class="p">)</span>
<span class="nb">assert</span><span class="p">(</span><span class="nf">loadstring</span><span class="p">(</span><span class="nv">dumped</span><span class="p">))</span><span class="w"> </span><span class="p">()</span>
<span class="c1">--> Retourne dans la console "Lancement de la fonction."</span>
</pre></div><p>Le <i><b>string.format()</b></i> renvoie une chaine de caractères formatée.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="nb">string.format</span><span class="p">(</span><span class="s2">"Je suis %s, j'adore les %s, et j'aime le nombre %i"</span><span class="p">,</span><span class="w"> </span><span class="s2">"gentil"</span><span class="p">,</span><span class="w"> </span><span class="s2">"bananes"</span><span class="p">,</span><span class="w"> </span><span class="mi">15</span><span class="p">))</span>
<span class="c1">--> Je suis gentil, j'adore les bananes, et j'aime le nombre 15</span>
<span class="c1">--> %s permet de rajouter des strings</span>
<span class="c1">--> %i permet de rajouter des nombres</span>
</pre></div><p>Le <i><b>string.gmatch(x, y)</b></i> renvoie une sous-chaîne de la chaîne principale x.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kr">for</span><span class="w"> </span><span class="nv">i</span><span class="w"> </span><span class="kr">in</span><span class="w"> </span><span class="nb">string.gmatch</span><span class="p">(</span><span class="s2">"Je suis quelqu'un de gentil"</span><span class="p">,</span><span class="w"> </span><span class="s2">"%a+"</span><span class="p">)</span><span class="w"> </span><span class="kr">do</span>
<span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="nv">i</span><span class="p">)</span>
<span class="kr">end</span>
<span class="c1">--> Je</span>
<span class="c1">--> suis</span>
<span class="c1">--> quelqu'</span>
<span class="c1">--> un</span>
<span class="c1">--> de</span>
<span class="c1">--> gentil</span>
</pre></div><p>Le <i><b>string.gsub(x, y, z)</b></i> remplace les mots y d'une string x par un autre mot z.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="nb">string.gsub</span><span class="p">(</span><span class="s2">"Je suis une personne"</span><span class="p">,</span><span class="w"> </span><span class="s2">"une personne"</span><span class="p">,</span><span class="w"> </span><span class="s2">"un zombie"</span><span class="p">))</span><span class="w"> </span><span class="c1">-- string.gsub(x(la string), y(mot à remplacer), z(mot qui remplace))</span>
<span class="c1">--> Je suis un zombie</span>
</pre></div><p>Le <i><b>string.upper(x)</b></i> renvoie le texte d'une string x en changeant les minuscules en MAJUSCULES (sauf caractères spéciaux).</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">MA_STRING</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"Je suis un éléphant Rose"</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">string.upper</span><span class="p">(</span><span class="nv">MA_STRING</span><span class="p">))</span>
<span class="c1">--> JE SUIS UN éLéPHANT ROSE</span>
</pre></div><p>Le <i><b>string.lower(x)</b></i> renvoie le texte d'une string x en changeant les MAJUSCULES en minuscules.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">MA_STRING</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"JE SUIS QUELQU'UN"</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">string.lower</span><span class="p">(</span><span class="nv">MA_STRING</span><span class="p">))</span>
<span class="c1">--> je suis quelqu'un</span>
</pre></div><p>Le <i><b>string.reverse(x)</b></i> retourne le texte d'une string x en inversant la chaîne de caractères.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">MA_STRING</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"je suis un scripter"</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">string.reverse</span><span class="p">(</span><span class="nv">MA_STRING</span><span class="p">))</span>
<span class="c1">--> retpircs nu sius ej</span>
</pre></div><p>Le <i><b>string.sub(x, y, z)</b></i> renvoie la sous-chaîne de x formée des caractères allant des indices y à z inclus (ou à la fin si z est absent). Si y ou z est négatif, la position est comptée à partir de la fin de la chaîne x.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">MA_STRING</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"je suis un scripter"</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">string.sub</span><span class="p">(</span><span class="nv">MA_STRING</span><span class="p">,</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="mi">7</span><span class="p">))</span><span class="w"> </span><span class="c1">--> je suis</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">string.sub</span><span class="p">(</span><span class="nv">MA_STRING</span><span class="p">,</span><span class="w"> </span><span class="o">-</span><span class="mi">2</span><span class="p">))</span><span class="w"> </span><span class="c1">--> er</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">string.sub</span><span class="p">(</span><span class="nv">MA_STRING</span><span class="p">,</span><span class="w"> </span><span class="o">-</span><span class="mi">5</span><span class="p">,</span><span class="w"> </span><span class="o">-</span><span class="mi">1</span><span class="p">))</span><span class="w"> </span><span class="c1">--> ipter</span>
</pre></div><p>Le <i><b>string.rep(x, y)</b></i> concatène y fois le contenu de la string x.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">MA_STRING</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"je suis "</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">string.rep</span><span class="p">(</span><span class="nv">MA_STRING</span><span class="p">,</span><span class="w"> </span><span class="mi">5</span><span class="p">))</span>
<span class="c1">--> je suis je suis je suis je suis je suis</span>
</pre></div><p>Le <i><b>string.match(x, y, z)</b></i> renvoie une sous-chaîne de caractères de la string x conforme au motif indiqué en y, et en cherchant à partir du caractère z (qui est facultatif).</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">MA_STRING</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"Je suis un scripter"</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">string.match</span><span class="p">(</span><span class="nv">MA_STRING</span><span class="p">,</span><span class="w"> </span><span class="s2">"s..."</span><span class="p">))</span><span class="w"> </span><span class="c1">--> suis</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">string.match</span><span class="p">(</span><span class="nv">MA_STRING</span><span class="p">,</span><span class="w"> </span><span class="s2">"s..."</span><span class="p">,</span><span class="w"> </span><span class="mi">12</span><span class="p">))</span><span class="w"> </span><span class="c1">--> scri</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="La_fonction_pairs()"><span id="La_fonction_pairs.28.29"></span>La fonction pairs()</h3></div><p>
La fonction pairs(x) énumère les index et les valeurs d'un tableau x. Elle replace table.foreach(), obsolète depuis Lua 5.1. A chaque itération, pairs(x) renvoie un index et la valeur associée à cet index dans le tableau. On prend souvent les noms de variables i et v: ainsi dans « for i, v in pairs(x) do …», i est un index dans x, et v est la valeur x[i].</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">tableau</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="s2">"premier"</span><span class="p">,</span><span class="w"> </span><span class="s2">"second"</span><span class="p">,</span><span class="w"> </span><span class="s2">"troisième"</span><span class="p">,</span><span class="w"> </span><span class="s2">"quatrième"</span><span class="p">,</span><span class="w"> </span><span class="s2">"cinquième"</span><span class="p">}</span>
<span class="kr">for</span><span class="w"> </span><span class="nv">i</span><span class="p">,</span><span class="w"> </span><span class="nv">v</span><span class="w"> </span><span class="kr">in</span><span class="w"> </span><span class="nb">pairs</span><span class="p">(</span><span class="nv">tableau</span><span class="p">)</span><span class="w"> </span><span class="kr">do</span>
<span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="nv">i</span><span class="p">,</span><span class="w"> </span><span class="nv">v</span><span class="p">)</span>
<span class="kr">end</span>
<span class="c1">--> Résultat dans la console:</span>
<span class="c1">-- 1 premier</span>
<span class="c1">-- 2 second</span>
<span class="c1">-- 3 troisième</span>
<span class="c1">-- 4 quatrième</span>
<span class="c1">-- 5 cinquième</span>
</pre></div><p>On peut aussi utiliser pairs() pour rechercher et retirer une valeur d'un tableau:</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">tableau</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="s2">"un"</span><span class="p">,</span><span class="w"> </span><span class="s2">"deux"</span><span class="p">,</span><span class="w"> </span><span class="s2">"trois"</span><span class="p">,</span><span class="w"> </span><span class="s2">"quatre"</span><span class="p">,</span><span class="w"> </span><span class="s2">"cinq"</span><span class="p">}</span>
<span class="kr">for</span><span class="w"> </span><span class="nv">index</span><span class="p">,</span><span class="w"> </span><span class="nv">value</span><span class="w"> </span><span class="kr">in</span><span class="w"> </span><span class="nb">pairs</span><span class="p">(</span><span class="nv">tableau</span><span class="p">)</span><span class="w"> </span><span class="kr">do</span>
<span class="w"> </span><span class="kr">if</span><span class="w"> </span><span class="nv">value</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s2">"trois"</span><span class="w"> </span><span class="kr">then</span>
<span class="w"> </span><span class="nb">table.remove</span><span class="p">(</span><span class="nv">tableau</span><span class="p">,</span><span class="w"> </span><span class="nv">index</span><span class="p">)</span><span class="w"> </span><span class="c1">-- Retire du tableau la valeur trois.</span>
<span class="w"> </span><span class="kr">break</span><span class="w"> </span><span class="c1">-- Arrêt de la boucle.</span>
<span class="w"> </span><span class="kr">end</span>
<span class="kr">end</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="La_fonction_pcall()"><span id="La_fonction_pcall.28.29"></span>La fonction pcall()</h3></div><p>
La fonction pcall() sert à capturer les erreurs qui surviennent dans une fonction. Dans ce cas, pcall() empêche l’arrêt du script et fournit les informations sur l’erreur.</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="w"> </span><span class="nb">pcall</span><span class="p">(</span><span class="kr">function</span><span class="p">()</span>
<span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="nv">table</span><span class="p">.</span><span class="nf">find</span><span class="p">(</span><span class="s2">"s"</span><span class="p">))</span><span class="w"> </span><span class="c1">--> est une erreur.</span>
<span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"Salut"</span><span class="p">)</span>
<span class="kr">end</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Je suis quelqu'un de gentil"</span><span class="p">)</span>
<span class="c1">--> Dans la console:</span>
<span class="c1">-- Je suis quelqu'un de gentil</span>
</pre></div><p>La fonction pcall() renvoie deux valeurs qui renseignent sur une erreur éventuelle:</p><div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">local</span><span class="w"> </span><span class="nv">success</span><span class="p">,</span><span class="w"> </span><span class="nv">err</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">pcall</span><span class="p">(</span><span class="kr">function</span><span class="p">()</span>
<span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="nv">table</span><span class="p">.</span><span class="nf">find</span><span class="p">(</span><span class="s2">"s"</span><span class="p">))</span><span class="w"> </span><span class="c1">--> est une erreur.</span>
<span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"Ca marche"</span><span class="p">)</span>
<span class="kr">end</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Je suis quelqu'un de gentil"</span><span class="p">)</span>
<span class="kr">if</span><span class="w"> </span><span class="ow">not</span><span class="w"> </span><span class="nv">success</span><span class="w"> </span><span class="kr">then</span><span class="w"> </span><span class="c1">-- Faute de succès, informer sur l’erreur</span>
<span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="nv">err</span><span class="p">)</span>
<span class="kr">end</span>
<span class="c1">--> Dans la console:</span>
<span class="c1">-- Je suis quelqu'un de gentil</span>
<span class="c1">-- Script:2: invalid argument #1 to 'find' (table expected, got string)</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Extensions_de_Lua_avec_l’API_C"><span id="Extensions_de_Lua_avec_l.E2.80.99API_C"></span>Extensions de Lua avec l’API C</h2></div>
<p>Comme expliqué dans PIL<sup id="cite_ref-4" class="reference"><a href="#cite_note-4"><span class="cite-bracket">[</span>4<span class="cite-bracket">]</span></a></sup>, la communication entre Lua et un programme C utilise une pile pour surmonter deux difficultés:
</p>
<ul><li>l’allocation de mémoire : elle est manuelle en C, alors que Lua a son ramasse-miettes. Les objets sont épargnés par le ramasse-miettes tant qu’ils sont sur la pile.</li>
<li>les types de données: statiques en C, dynamiques en Lua. l’API C offre notamment des fonctions de conversion entre les valeurs sur la pile et les types du C.</li></ul>
<p>L’API C gère aussi la persistence des données par deux mécanismes<sup id="cite_ref-5" class="reference"><a href="#cite_note-5"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup>:
</p>
<ul><li>un registre (qui permet à toutes les fonctions C de partager des informations)</li>
<li>les "upvalues" (valeurs de contexte que l’on peut associer à une fonction C). Cela permet entre autres à un programme C de prendre une seule fonction C pour en tirer plusieurs fonctions LUA -- des closures -- qui ne diffèrent que par leur contexte. L’exemple classique est celui des fonctions de comptage dont les compteurs doivent être indépendants.</li></ul>
<div class="mw-heading mw-heading2"><h2 id="Exemples">Exemples</h2></div>
<div class="mw-heading mw-heading3"><h3 id="Hello_World">Hello World</h3></div>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="s1">'Hello World!'</span><span class="p">)</span>
<span class="c1">----------------------------</span>
<span class="nb">io.write</span><span class="p">(</span><span class="s2">"Hello World!"</span><span class="p">)</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Help">Help</h3></div>
<p>Fonction donnant le type d’un objet, et les indices, types et valeurs de ses éléments si c’est un objet table.
Peut servir comme aide-mémoire des fonctions de bibliothèque io, table, string, etc.
</p>
<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr"><pre><span></span><span class="kr">function</span><span class="w"> </span><span class="nf">help</span><span class="p">(</span><span class="nv">o</span><span class="p">)</span><span class="w"> </span><span class="c1">-- essayer help(io), help(table), …</span>
<span class="w"> </span><span class="kd">local</span><span class="w"> </span><span class="nv">t</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">type</span><span class="p">(</span><span class="nv">o</span><span class="p">)</span><span class="w"> </span><span class="c1">-- Type sous forme de chaîne</span>
<span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"Type:"</span><span class="p">,</span><span class="w"> </span><span class="nv">t</span><span class="p">)</span>
<span class="w"> </span><span class="kr">if</span><span class="w"> </span><span class="p">(</span><span class="nv">t</span><span class="o">==</span><span class="s2">"table"</span><span class="p">)</span><span class="w"> </span><span class="kr">then</span>
<span class="w"> </span><span class="kd">local</span><span class="w"> </span><span class="nv">i</span><span class="p">,</span><span class="nv">v</span>
<span class="w"> </span><span class="kr">for</span><span class="w"> </span><span class="nv">i</span><span class="p">,</span><span class="nv">v</span><span class="w"> </span><span class="kr">in</span><span class="w"> </span><span class="nb">pairs</span><span class="p">(</span><span class="nv">o</span><span class="p">)</span><span class="w"> </span><span class="kr">do</span><span class="w"> </span><span class="c1">-- Fonction d’itération pairs</span>
<span class="w"> </span><span class="nb">print</span><span class="p">(</span><span class="nv">i</span><span class="p">,</span><span class="nb">type</span><span class="p">(</span><span class="nv">v</span><span class="p">),</span><span class="nv">v</span><span class="p">)</span><span class="w"> </span><span class="c1">-- Ex: «stdin userdata file (00007FF96219F490)»</span>
<span class="w"> </span><span class="kr">end</span>
<span class="w"> </span><span class="kr">end</span>
<span class="kr">end</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Usages">Usages</h2></div>
<div class="mw-heading mw-heading3"><h3 id="Consoles">Consoles</h3></div>
<p>Lua a été embarqué dans la <a href="PlayStation_Portable" title="PlayStation Portable">PlayStation Portable</a> de <a href="Sony" title="Sony">Sony</a>, grâce au programme Lua Player, et plus récemment Lua Player HM et Lua Player Euphoria qui permettent de lire des applications écrites avec Lua afin d'étendre les capacités de la console. Viendra plus tard l'XtreamLua Player, destiné à la création de jeux vidéo. Une modification (non officielle) du <a href="Micrologiciel" class="mw-redirect" title="Micrologiciel">micrologiciel</a> de la PSP permettait de lancer des programmes non-signés par Sony d'où la création d'un interpréteur Lua adapté pour la PSP.
</p><p>Lua Player Euphoria reprend la syntaxe du Lua Player original et exécute le script à une vitesse fulgurante comparé au Lua Player HM. Cependant, Lua Player Euphoria est moins complet que son homologue plus ancien.
</p><p>Lua Player One, un des derniers Lua Player mis à jour pour PSP, est un Lua Player développé au sein d'une communauté de développeurs espagnols ; il permet, entre autres, de gérer la 3D sur PSP. Un jeu de mini-golf dans l'espace a été développé à l'aide de cet outil.
</p><p>Lua Player Plus (LPP) est sorti sur <a href="PlayStation_Vita" title="PlayStation Vita">PlayStation Vita</a> le <time class="nowrap" datetime="2015-08-16" data-sort-value="2015-08-16">16 août 2015</time>. Ce Lua Player permet de créer des jeux pour la console.
</p><p>Lua est inclus dans la console de poche open-source <a rel="nofollow" class="external text" href="http://www.chip-pc.fr/pocket-chip/">Pocket Chip</a> (projet <a rel="nofollow" class="external text" href="https://www.kickstarter.com/projects/1598272670/chip-the-worlds-first-9-computer/description">Kickstater</a>). En effet cette dernière embarque le programme de console virtuel <a rel="nofollow" class="external text" href="http://www.lexaloffle.com/pico-8.php">Pico-8</a> qui permet de jouer et de créer des jeux en Lua.
</p>
<div class="mw-heading mw-heading3"><h3 id="Extensions_de_jeux_vidéo"><span id="Extensions_de_jeux_vid.C3.A9o"></span>Extensions de jeux vidéo</h3></div>
<p>Parmi les <a href="Jeu_vid%C3%A9o" title="Jeu vidéo">jeux vidéo</a> de <a href="Jeu_sandbox" title="Jeu sandbox">bac à sable</a> qui l'utilisent figurent <i><a href="Garry's_Mod" title="Garry's Mod">Garry's Mod</a></i>, <i><a href="Roblox" title="Roblox">Roblox</a></i>, <a href="https://en.wikipedia.org/wiki/Core_(video_game)" class="extiw external" title="en:Core (video game)"><i>Core</i></a>, Stormworks <a href="https://en.wikipedia.org/wiki/Stormworks:_Build_and_Rescue" class="extiw external" title="en:Stormworks: Build and Rescue"><span class="indicateur-langue" title="Article en anglais : « Stormworks:_Build_and_Rescue »">(en)</span></a> et <i><a href="Minecraft" title="Minecraft">Minecraft</a></i>. Pour ce dernier, <i><a href="ComputerCraft" title="ComputerCraft">ComputerCraft</a></i><sup id="cite_ref-6" class="reference"><a href="#cite_note-6"><span class="cite-bracket">[</span>6<span class="cite-bracket">]</span></a></sup>, un mod du jeu <i><a href="Minecraft" title="Minecraft">Minecraft</a></i>, utilise Lua pour concevoir des programmes graphiques ou consoles et des « robots » autonomes à l'intérieur du jeu, permettant d'automatiser de nombreuses tâches répétitives ; <i>Minetest</i>, un <a href="Jeu_sandbox" title="Jeu sandbox">jeu sandbox</a> sous licence LGPL similaire à ce dernier, utilise Lua comme langage pour l'écriture d'extensions et à l'intérieur même du jeu (via certains modes)<sup id="cite_ref-7" class="reference"><a href="#cite_note-7"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup> via la programmation de <a href="Microcontr%C3%B4leur" title="Microcontrôleur">microcontrôleur</a> ou de <a href="FPGA" class="mw-redirect" title="FPGA">FPGA</a>.
</p><p>Il existe également un moteur de jeu utilisant Lua comme langage de programmation (une sorte de <a href="Pygame" title="Pygame">Pygame</a> pour Lua) : <a href="L%C3%96VE" title="LÖVE">LÖVE</a>.
</p><p>Beaucoup d'autres jeux vidéo l'utilisent, comme <i><a href="World_of_Warcraft" title="World of Warcraft">World of Warcraft</a></i> de <a href="Blizzard_Entertainment" title="Blizzard Entertainment">Blizzard Entertainment</a>, <i><a href="Far_Cry_(jeu_vid%C3%A9o)" title="Far Cry (jeu vidéo)">Far Cry</a></i> (et le moteur <a href="CryEngine" title="CryEngine">CryEngine</a> en général) de <a href="Crytek_Studios" class="mw-redirect" title="Crytek Studios">Crytek Studios</a>, le logiciel multijoueurs de <a href="Grand_Theft_Auto%3A_San_Andreas" title="Grand Theft Auto: San Andreas">GTA:SA</a> <i><a href="Multi_Theft_Auto" title="Multi Theft Auto">Multi Theft Auto</a></i>, <i><a href="SimCity_4" title="SimCity 4">SimCity 4</a></i> et <i><a href="Natural_Selection_2" title="Natural Selection 2">Natural Selection 2</a></i> de <a href="Unknown_Worlds_Entertainment" title="Unknown Worlds Entertainment">Unknown Worlds Entertainment</a> (qui a entre autres développé Decoda, un <a href="Environnement_de_d%C3%A9veloppement_int%C3%A9gr%C3%A9" class="mw-redirect" title="Environnement de développement intégré">IDE</a> pour Lua). Enfin, certains scripts de <i><a href="Zoo_Tycoon_2" title="Zoo Tycoon 2">Zoo Tycoon 2</a></i> (Blue Fang Games) sont également présents sous des formes non compilées dans les fichiers du jeu. <i><a href="The_Binding_of_Isaac%3A_Rebirth#Afterbirth_†" title="The Binding of Isaac: Rebirth">The Binding of Isaac: Afterbirth+</a></i> est un <a href="Contenu_t%C3%A9l%C3%A9chargeable" class="mw-redirect" title="Contenu téléchargeable">DLC</a> pour le jeu <i><a href="The_Binding_of_Isaac%3A_Rebirth" title="The Binding of Isaac: Rebirth">The Binding of Isaac: Rebirth</a></i> qui permet le support de mods écrits en Lua<sup id="cite_ref-8" class="reference"><a href="#cite_note-8"><span class="cite-bracket">[</span>8<span class="cite-bracket">]</span></a></sup>.
</p><p>Lua sert aussi dans des jeux comme : <i><a href="Minetest" class="mw-redirect" title="Minetest">Minetest</a></i>, <i><a href="Transformice" title="Transformice">Transformice</a></i>, <i><a href="Roblox" title="Roblox">Roblox</a></i>, <i>Onset</i>, <i><a href="Multi_Theft_Auto" title="Multi Theft Auto">Multi Theft Auto</a></i> (<a href="Mod_(jeu_vid%C3%A9o)" title="Mod (jeu vidéo)">mod</a> multijoueur de <i><a href="Grand_Theft_Auto%3A_San_Andreas" title="Grand Theft Auto: San Andreas">Grand Theft Auto: San Andreas</a></i>), <i>FiveM</i> (<a href="Mod_(jeu_vid%C3%A9o)" title="Mod (jeu vidéo)">mod</a> multijoueur de <i><a href="Grand_Theft_Auto_V" title="Grand Theft Auto V">Grand Theft Auto V</a></i>), <i><a href="Factorio" title="Factorio">Factorio</a></i>, <i><a href="Project_Zomboid" title="Project Zomboid">Project Zomboid</a></i>, <i>nanos world</i><sup id="cite_ref-9" class="reference"><a href="#cite_note-9"><span class="cite-bracket">[</span>9<span class="cite-bracket">]</span></a></sup>,<i><a href="Balatro" title="Balatro">Balatro</a></i> ainsi que les moteurs de jeu vidéo tels que le <a href="Source_(moteur_de_jeu)" title="Source (moteur de jeu)">SourceEngine</a>, <a href="L%C3%96VE" title="LÖVE">LÖVE</a>, <a href="Solarus_(moteur_de_jeu)" title="Solarus (moteur de jeu)">Solarus</a> ou encore les <a href="Fantasy_console" title="Fantasy console">Fantasy consoles</a>, tel que <a href="Pico-8" title="Pico-8">Pico-8</a>.
</p>
<div class="mw-heading mw-heading3"><h3 id="Réseau_et_Embarqué"><span id="R.C3.A9seau_et_Embarqu.C3.A9"></span>Réseau et Embarqué</h3></div>
<p>Au niveau réseau, Lua sert comme <a href="Hook_(informatique)" title="Hook (informatique)">hook</a> sur <a href="Apache_HTTP_Server" title="Apache HTTP Server">Apache</a>, <a href="Lighttpd" title="Lighttpd">Lighttpd</a> (par défaut), <a href="Nginx" class="mw-redirect" title="Nginx">Nginx</a> (via OpenResty), dans les routeurs <a href="Cisco" class="mw-redirect" title="Cisco">Cisco</a>, dans l'<a href="Analyseur_de_paquets" title="Analyseur de paquets">analyseur de paquets</a> <a href="Wireshark" title="Wireshark">Wireshark</a>,
</p><p>La compacité de Lua est très appréciée dans des <a href="Syst%C3%A8me_embarqu%C3%A9" title="Système embarqué">systèmes embarqués</a> tels qu'<a href="OpenWrt" title="OpenWrt">OpenWrt</a><sup id="cite_ref-10" class="reference"><a href="#cite_note-10"><span class="cite-bracket">[</span>10<span class="cite-bracket">]</span></a></sup>.
</p><p>Le PABX <a href="Asterisk_(logiciel)" title="Asterisk (logiciel)">Asterisk</a> (<a href="Autocommutateur_t%C3%A9l%C3%A9phonique_priv%C3%A9" title="Autocommutateur téléphonique privé">autocommutateur téléphonique privé</a>) propose Lua comme alternative pour étendre son plan de numérotation.
</p><p>L'<a href="Antispam" class="mw-redirect" title="Antispam">antispam</a> <a href="Rspamd" title="Rspamd">Rspamd</a> utilise également Lua pour son <a href="Interface_de_programmation" title="Interface de programmation">interface de programmation</a><sup id="cite_ref-11" class="reference"><a href="#cite_note-11"><span class="cite-bracket">[</span>11<span class="cite-bracket">]</span></a></sup>.
</p>
<div class="mw-heading mw-heading3"><h3 id="Autres_logiciels">Autres logiciels</h3></div>
<p>Lua est également utilisé pour l'extension des capacités du lecteur multimédia <a href="VLC_media_player" title="VLC media player">VLC</a>, dans les <a href="Gestionnaire_de_fen%C3%AAtre" class="mw-redirect" title="Gestionnaire de fenêtre">gestionnaires de fenêtres</a> EFL Edje d'<a href="Enlightenment_(logiciel)" title="Enlightenment (logiciel)">Enlightenment</a>, dans <a href="Neovim" title="Neovim">NeoVim</a> pour sa configuration, ainsi que <a href="Awesome_(logiciel)" title="Awesome (logiciel)">Awesome</a> (comme langage de configuration et de script).
</p><p><a href="MediaWiki" title="MediaWiki">MediaWiki</a> et les sites <a href="Wikimedia" class="mw-redirect" title="Wikimedia">Wikimedia</a> utilisent Lua comme langage de script pour les modèles (appelés modules)<sup id="cite_ref-12" class="reference"><a href="#cite_note-12"><span class="cite-bracket">[</span>12<span class="cite-bracket">]</span></a></sup>.
</p><p>Le logiciel CraftStudio utilise Lua pour programmer les éléments dynamiques des modèles.
</p><p>Le logiciel libre d'<a href="Interface_neuronale_directe" title="Interface neuronale directe">interface neuronale directe</a> OpenVibe <a href="https://en.wikipedia.org/wiki/OpenVibe" class="extiw external" title="en:OpenVibe"><span class="indicateur-langue" title="Article en anglais : « OpenVibe »">(en)</span></a> utilise Lua comme langage de script, en particulier pour la gestion de stimuli pour les expériences de neuroscience.
</p><p>Le robot IRC irccd<sup id="cite_ref-13" class="reference"><a href="#cite_note-13"><span class="cite-bracket">[</span>13<span class="cite-bracket">]</span></a></sup> utilise Lua pour la création de plugins.
</p><p>Lua est le langage de scripting principalement utilisé pour le <a href="Syst%C3%A8me_d'exploitation" title="Système d'exploitation">système d'exploitation</a> embarqué <a href="OpenWrt" title="OpenWrt">OpenWrt</a> fonctionnant sur de nombreux routeurs. L'interface graphique d'administration LuCI est entièrement écrite en Lua.
</p><p>Lua est le langage natif de Domoticz, logiciel de <a href="Domotique" title="Domotique">domotique</a> <i><span class="lang-en" lang="en">open source</span></i>. Il permet le <i><span class="lang-en" lang="en">scripting</span></i> avec des fonctionnalités avancées : Domoticz déclenche automatiquement ces scripts sur les changements d’états, en fonction du temps, etc.
</p><p>Lua est également le langage natif de <a href="https://sourceforge.net/projects/nsbase/" class="extiw external" title="sourceforge:projects/nsbase/">NSBase</a>, logiciel de gestion de bases données. Le scripting permet de dynamiser les formulaires, rapports. Lua ainsi intégré permet de créer de véritables applications de gestion de bases de données.
</p><p>Le logiciel de simulation de vol spatial <a href="Orbiter_(simulateur)" title="Orbiter (simulateur)">Orbiter</a> et ses add-ons (UCGO, UMmu) utilisent Lua pour permettre la création aisée d'écrans de contrôle (<a href="MFD" class="mw-redirect" title="MFD">MFD</a> - Multi Function Display), de missions ou de vaisseaux. La création de vaisseaux, en particulier, à la différence de modules <a href="Dynamic_Link_Library" title="Dynamic Link Library">DLL</a>, ne nécessite pas la compilation d'un fichier <a href="C%2B%2B" title="C++">C++</a>.
</p><p><a href="BeamNG.drive" title="BeamNG.drive">BeamNG.drive</a><sup id="cite_ref-14" class="reference"><a href="#cite_note-14"><span class="cite-bracket">[</span>14<span class="cite-bracket">]</span></a></sup> utilise Lua pour compléter ses équations physiques.
</p><p><a href="Prosody" title="Prosody">Prosody</a> : serveur <a href="XMPP" class="mw-redirect" title="XMPP">XMPP</a> léger écrit entièrement en lua.
</p><p>L'environnement de bureau <a href="Awesome_(logiciel)" title="Awesome (logiciel)">Awesome (linux)</a> utilise aussi Lua dans ses fichiers de configuration depuis sa version 3.
</p><p><a href="FreeBSD" title="FreeBSD">FreeBSD</a> intègre un interpréteur lua dans son chargeur depuis la version 11.3<sup id="cite_ref-15" class="reference"><a href="#cite_note-15"><span class="cite-bracket">[</span>15<span class="cite-bracket">]</span></a></sup>.
</p><p>La solution qui associe le montage, l’étalonnage, les effets visuels, les animations graphiques et la post-production audio <a href="DaVinci_Resolve" title="DaVinci Resolve">Davinci Resolve</a> utilise Lua, Py2 et Py3.
</p><p>Le logiciel de notation musicale professionnel <a href="Finale_(logiciel)" title="Finale (logiciel)">Finale</a> propose un <a href="Plugin" title="Plugin">plugin</a> Lua.
</p>
<div class="mw-heading mw-heading2"><h2 id="Notes_et_références"><span id="Notes_et_r.C3.A9f.C3.A9rences"></span>Notes et références</h2></div>
<div class="references-small decimal" style=""><div class="mw-references-wrap mw-references-columns"><ol class="references">
<li id="cite_note-wikidata-0a30228504911f642387a91b3bc4df31672ca70c-1"><span class="reference-text"><span class="ouvrage">« <a rel="nofollow" class="external text" href="https://groups.google.com/g/lua-l/c/cUHfNqHFviM"><cite style="font-style:normal;"><span class="lang-en" lang="en">[ANN] Lua 5.4.8 now available</span></cite></a> », <time class="nowrap" datetime="2025-06-04" data-sort-value="2025-06-04">4 juin 2025</time> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2025-06-05" data-sort-value="2025-06-05">5 juin 2025</time>)</small></span></span>
</li>
<li id="cite_note-2"><span class="mw-cite-backlink"><a href="#cite_ref-2">↑</a> </span><span class="reference-text"><span class="ouvrage"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> « <a rel="nofollow" class="external text" href="https://www.lua.org/about.html"><cite style="font-style:normal;" lang="en">About</cite></a> », sur <span class="italique">lua.org</span></span>.</span>
</li>
<li id="cite_note-3"><span class="mw-cite-backlink"><a href="#cite_ref-3">↑</a> </span><span class="reference-text"><span class="ouvrage"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> « <a rel="nofollow" class="external text" href="https://www.lua.org/doc/hopl.pdf"><cite style="font-style:normal;" lang="en">The Evolution of Lua</cite></a> », sur <span class="italique">lua.org</span> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2025-03-21" data-sort-value="2025-03-21">21 mars 2025</time>)</small></span></span>
</li>
<li id="cite_note-4"><span class="mw-cite-backlink"><a href="#cite_ref-4">↑</a> </span><span class="reference-text"><span class="ouvrage"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> « <a rel="nofollow" class="external text" href="https://www.lua.org/pil/24.html"><cite style="font-style:normal;" lang="en">Programming in Lua (§24)</cite></a> », sur <span class="italique">lua.org</span> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2025-03-25" data-sort-value="2025-03-25">25 mars 2025</time>)</small></span></span>
</li>
<li id="cite_note-5"><span class="mw-cite-backlink"><a href="#cite_ref-5">↑</a> </span><span class="reference-text"><span class="ouvrage"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> « <a rel="nofollow" class="external text" href="https://www.lua.org/pil/27.3.html"><cite style="font-style:normal;" lang="en">Programming in Lua (§27.3)</cite></a> », sur <span class="italique">lua.org</span> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2025-03-25" data-sort-value="2025-03-25">25 mars 2025</time>)</small></span></span>
</li>
<li id="cite_note-6"><span class="mw-cite-backlink"><a href="#cite_ref-6">↑</a> </span><span class="reference-text"><a rel="nofollow" class="external text" href="http://computercraft.info">Site internet du mod <i>ComputerCraft</i></a>.</span>
</li>
<li id="cite_note-7"><span class="mw-cite-backlink"><a href="#cite_ref-7">↑</a> </span><span class="reference-text"><a rel="nofollow" class="external text" href="https://content.minetest.net/packages/Jeija/mesecons/">Mode de Minetest ajoutant des circuits électroniques numériques et analogique (tels que des portes logiques, des µcontrôleurs ou des FPGA) et permettant l'automatisation de certaines actions et événements.</a></span>
</li>
<li id="cite_note-8"><span class="mw-cite-backlink"><a href="#cite_ref-8">↑</a> </span><span class="reference-text"><span class="ouvrage"><span class="noarchive">« <a rel="nofollow" class="external text" href="http://bindingofisaac.com/post/153791362179/tyrone-not-again"><cite style="font-style:normal; color:var(--color-link-red, #d73333);">TYRONE! NOT AGAIN!</cite></a> »<sup class="">(<a rel="nofollow" class="external text" href="https://web.archive.org/web/*/http://bindingofisaac.com/post/153791362179/tyrone-not-again">Archive.org</a> • <a rel="nofollow" class="external text" href="https://archive.wikiwix.com/cache/?url=http://bindingofisaac.com/post/153791362179/tyrone-not-again">Wikiwix</a> • <a rel="nofollow" class="external text" href="https://archive.is/http://bindingofisaac.com/post/153791362179/tyrone-not-again">Archive.is</a> • <a rel="nofollow" class="external text" href="https://webcache.googleusercontent.com/search?hl=fr&q=cache:http://bindingofisaac.com/post/153791362179/tyrone-not-again">Google</a> • Que faire ?)</sup></span>, sur <span class="italique">†</span> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2017-01-06" data-sort-value="2017-01-06">6 janvier 2017</time>)</small></span>.</span>
</li>
<li id="cite_note-9"><span class="mw-cite-backlink"><a href="#cite_ref-9">↑</a> </span><span class="reference-text"><a rel="nofollow" class="external text" href="https://store.steampowered.com/app/1841660/nanos_world/"><i>nanos world™</i></a>.</span>
</li>
<li id="cite_note-10"><span class="mw-cite-backlink"><a href="#cite_ref-10">↑</a> </span><span class="reference-text"><span class="ouvrage" id="2017"><cite class="italique">Luci : LuCI : OpenWrt Configuration Interface</cite>, openwrt, <time class="nowrap" datetime="2017-10-12" data-sort-value="2017-10-12">12 octobre 2017</time> <small style="line-height:1em;">(<a rel="nofollow" class="external text" href="https://github.com/openwrt/luci">lire en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rft.genre=book&rft.btitle=Luci&rft.pub=openwrt&rft.stitle=LuCI+%3A+OpenWrt+Configuration+Interface&rft.date=2017-10-12&rfr_id=info%3Asid%2Ffr.wikipedia.org%3ALua"></span></span>.</span>
</li>
<li id="cite_note-11"><span class="mw-cite-backlink"><a href="#cite_ref-11">↑</a> </span><span class="reference-text"><span class="ouvrage"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> « <a rel="nofollow" class="external text" href="https://rspamd.com/features.html"><cite style="font-style:normal;" lang="en">Rspamd Features — Unique features</cite></a> », sur <span class="italique">rspamd.com</span></span>.</span>
</li>
<li id="cite_note-12"><span class="mw-cite-backlink"><a href="#cite_ref-12">↑</a> </span><span class="reference-text">Wikipedia Signpost, <a href="https://en.wikipedia.org/wiki/Wikipedia:Wikipedia_Signpost/2012-01-30/Technology_report" class="extiw external" title="en:Wikipedia:Wikipedia Signpost/2012-01-30/Technology report">Lua chosen as new template scripting language</a>, 30 janvier 2012 (<a href="https://www.mediawiki.org/wiki/Lua_scripting" class="extiw external" title="mw:Lua scripting">Page de projet</a>).</span>
</li>
<li id="cite_note-13"><span class="mw-cite-backlink"><a href="#cite_ref-13">↑</a> </span><span class="reference-text"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> <a rel="nofollow" class="external text" href="http://projects.malikania.fr/irccd">« <span class="lang-en" lang="en">IRC Client Daemon</span> »</a>.</span>
</li>
<li id="cite_note-14"><span class="mw-cite-backlink"><a href="#cite_ref-14">↑</a> </span><span class="reference-text"><span class="ouvrage">« <a rel="nofollow" class="external text" href="http://www.beamng.com/"><cite style="font-style:normal;">BeamNG.drive</cite></a> » <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2016-08-06" data-sort-value="2016-08-06">6 août 2016</time>)</small></span>.</span>
</li>
<li id="cite_note-15"><span class="mw-cite-backlink"><a href="#cite_ref-15">↑</a> </span><span class="reference-text"><span class="ouvrage">« <a rel="nofollow" class="external text" href="https://www.freebsd.org/releases/11.3R/relnotes/"><cite style="font-style:normal;">The FreeBSD Project | FreeBSD 11.3-RELEASE Release Notes</cite></a> », sur <span class="italique">freebsd.org</span> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2021-04-22" data-sort-value="2021-04-22">22 avril 2021</time>)</small></span>.</span>
</li>
</ol></div>
</div>
<div class="mw-heading mw-heading2"><h2 id="Annexes">Annexes</h2></div>
<style data-mw-deduplicate="TemplateStyles:r194021218">
/* start https://fr.wikipedia.org/ */
.mw-parser-output .autres-projets>.titre{text-align:center;margin:0.2em 0}.mw-parser-output .autres-projets>ul{margin:0;padding:0}.mw-parser-output .autres-projets>ul>li{list-style:none;margin:0.2em 0;text-indent:0;padding-left:24px;min-height:20px;text-align:left;display:block}.mw-parser-output .autres-projets>ul>li>a{font-style:italic}@media(max-width:720px){.mw-parser-output .autres-projets{float:none}}
/* end https://fr.wikipedia.org/ */
</style>
<div class="mw-heading mw-heading3"><h3 id="Bibliographie">Bibliographie</h3></div>
<ul><li><span class="ouvrage"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> « <a rel="nofollow" class="external text" href="http://www.lua.org/manual/5.2/"><cite style="font-style:normal;" lang="en">Lua 5.2 Reference Manual</cite></a> », sur <span class="italique">lua.org</span>, Lua.org et <a href="Universit%C3%A9_pontificale_catholique_de_Rio_de_Janeiro" title="Université pontificale catholique de Rio de Janeiro">université pontificale catholique de Rio de Janeiro</a> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2014-05-14" data-sort-value="2014-05-14">14 mai 2014</time>)</small></span></li>
<li><span class="ouvrage" id="Ierusalimschy2013"><span class="ouvrage" id="Roberto_Ierusalimschy2013"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> Roberto <span class="nom_auteur">Ierusalimschy</span>, <cite class="italique" lang="en">Programming in Lua</cite>, Rio de Janeiro, Lua.org et <a href="Universit%C3%A9_pontificale_catholique_de_Rio_de_Janeiro" title="Université pontificale catholique de Rio de Janeiro">université pontificale catholique de Rio de Janeiro</a>, <time class="nowrap" datetime="2013-01" data-sort-value="2013-01">janvier 2013</time>, <abbr class="abbr" title="troisième">3<sup>e</sup></abbr> <abbr class="abbr" title="édition">éd.</abbr> (<abbr class="abbr" title="première">1<sup>re</sup></abbr> <abbr class="abbr" title="édition">éd.</abbr> 2003), 347 <abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a> <span class="nowrap">978-85-903798-5-0</span> et <span class="nowrap">85-903798-5-X</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rft.genre=book&rft.btitle=Programming+in+Lua&rft.place=Rio+de+Janeiro&rft.pub=universit%C3%A9+pontificale+catholique+de+Rio+de+Janeiro&rft.edition=3&rft.aulast=Ierusalimschy&rft.aufirst=Roberto&rft.date=2013-01&rft.tpages=347&rft.isbn=978-85-903798-5-0&rfr_id=info%3Asid%2Ffr.wikipedia.org%3ALua"></span></span></span></li>
<li><span class="ouvrage" id="IerusalimschyCelesFigueiredo2008"><span class="ouvrage" id="Roberto_IerusalimschyWaldemar_CelesLuiz_Henrique_de_Figueiredo2008"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> Roberto <span class="nom_auteur">Ierusalimschy</span>, Waldemar <span class="nom_auteur">Celes</span> et Luiz Henrique de <span class="nom_auteur">Figueiredo</span>, <cite class="italique" lang="en">Lua Programming Gems</cite>, Rio de Janeiro, Brésil, Lua.org et <a href="Universit%C3%A9_pontificale_catholique_de_Rio_de_Janeiro" title="Université pontificale catholique de Rio de Janeiro">université pontificale catholique de Rio de Janeiro</a>, <time>2008</time>, 346 <abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a> <span class="nowrap">978-85-903798-4-3</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rft.genre=book&rft.btitle=Lua+Programming+Gems&rft.place=Rio+de+Janeiro%2C+Br%C3%A9sil&rft.pub=universit%C3%A9+pontificale+catholique+de+Rio+de+Janeiro&rft.aulast=Ierusalimschy&rft.aufirst=Roberto&rft.au=Celes%2C+Waldemar&rft.au=Figueiredo%2C+Luiz+Henrique+de&rft.date=2008&rft.tpages=346&rft.isbn=978-85-903798-4-3&rfr_id=info%3Asid%2Ffr.wikipedia.org%3ALua"></span></span></span></li>
<li><span class="ouvrage" id="Cyril_DoillonSylvain_FabrePhilippe_LhostePatrick_Rapin2012"><span class="nom_auteur">Cyril Doillon</span> (<abbr class="abbr" title="directeur de publication">dir.</abbr>), <span class="nom_auteur">Sylvain Fabre</span>, <span class="nom_auteur">Philippe Lhoste</span> et <span class="nom_auteur">Patrick Rapin</span>, <cite class="italique">Le guide de Lua et ses applications : manuel d'apprentissage</cite>, Paris, D-BookeR édition, <time>2012</time>, 188 <abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a> <span class="nowrap">978-2-8227-0005-4</span>, <a rel="nofollow" class="external text" href="http://www.d-booker.fr/programmation-et-langage/1-livre-lua.html%20(payant)">lire en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rft.genre=book&rft.btitle=Le+guide+de+Lua+et+ses+applications&rft.place=Paris&rft.pub=D-BookeR+%C3%A9dition&rft.stitle=manuel+d%27apprentissage&rft.aulast=Cyril+Doillon&rft.au=Sylvain+Fabre&rft.au=Philippe+Lhoste&rft.au=Patrick+Rapin&rft.date=2012&rft.tpages=188&rft.isbn=978-2-8227-0005-4&rfr_id=info%3Asid%2Ffr.wikipedia.org%3ALua"></span></span></li>
<li><span class="ouvrage" id="Cyril_DoillonSylvain_FabrePhilippe_LhostePatrick_Rapin2012"><span class="nom_auteur">Cyril Doillon</span> (<abbr class="abbr" title="directeur de publication">dir.</abbr>), <span class="nom_auteur">Sylvain Fabre</span>, <span class="nom_auteur">Philippe Lhoste</span> et <span class="nom_auteur">Patrick Rapin</span>, <cite class="italique">Le guide de Lua et ses applications : manuel de référence</cite>, Paris, D-BookeR édition, <time>2012</time>, 336 <abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a> <span class="nowrap">978-2-8227-0015-3</span>, <a rel="nofollow" class="external text" href="http://www.d-booker.fr/programmation-et-langage/1-livre-lua.html%20(payant)">lire en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rft.genre=book&rft.btitle=Le+guide+de+Lua+et+ses+applications&rft.place=Paris&rft.pub=D-BookeR+%C3%A9dition&rft.stitle=manuel+de+r%C3%A9f%C3%A9rence&rft.aulast=Cyril+Doillon&rft.au=Sylvain+Fabre&rft.au=Philippe+Lhoste&rft.au=Patrick+Rapin&rft.date=2012&rft.tpages=336&rft.isbn=978-2-8227-0015-3&rfr_id=info%3Asid%2Ffr.wikipedia.org%3ALua"></span></span></li></ul>
<div class="mw-heading mw-heading3"><h3 id="Articles_connexes">Articles connexes</h3></div>
<ul><li><a href="Plua" title="Plua">Plua</a></li>
<li><a href="LuaTeX" title="LuaTeX">LuaTeX</a></li>
<li>GLua</li></ul>
<div class="mw-heading mw-heading3"><h3 id="Liens_externes">Liens externes</h3></div>
<p class="mw-empty-elt">
</p>
<ul><li><cite class="ouvrage" id="site_officiel" style="font-style: normal;"><span class="wd_p856"><abbr class="abbr indicateur-langue" title="Langues : anglais et portugais">(en + pt)</abbr> <a rel="nofollow" class="external text" href="https://lua.org">Site officiel</a></span></cite></li>
<li class="mw-empty-elt"></li>
<li class="mw-empty-elt"></li>
<li><div class="liste-horizontale"><span class="wd_identifiers"><a href="Autorit%C3%A9_(sciences_de_l'information)" title="Autorité (sciences de l'information)">Notices d'autorité</a></span> : <ul><li><span class="nowrap uid noarchive"><a rel="nofollow" class="external text" href="https://catalogue.bnf.fr/ark:/12148/cb166522948">BnF</a></span> (<span class="nowrap uid noarchive"><a rel="nofollow" class="external text" href="https://data.bnf.fr/ark:/12148/cb166522948">données</a></span>)</li> <li><span class="nowrap uid noarchive"><a rel="nofollow" class="external text" href="http://id.loc.gov/authorities/sh2004007514">LCCN</a></span></li> <li><span class="nowrap uid noarchive"><a rel="nofollow" class="external text" href="http://d-nb.info/gnd/7547043-3">GND</a></span></li> <li><span class="nowrap uid noarchive"><a rel="nofollow" class="external text" href="https://www.nli.org.il/en/authorities/987007563918605171">Israël</a></span></li> </ul></div></li>
<li><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> <a rel="nofollow" class="external text" href="https://eclipse.org/ldt/">Lua Development Tools</a></li>
<li><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> <a rel="nofollow" class="external text" href="http://www.eluaproject.net/">Lua embarqué</a></li>
<li><abbr class="abbr indicateur-langue" title="Langue : français">(fr)</abbr> <a rel="nofollow" class="external text" href="http://www.luteus.biz/Download/LoriotPro_Doc/LUA/LUA_Training_FR/Introduction_Programmation.html">Introduction à la programmation avec Lua</a></li></ul>
<div class="navbox-container" style="clear:both;">
</div>
<ul id="bandeau-portail" class="bandeau-portail"><li><span class="bandeau-portail-element"><span class="bandeau-portail-icone"><span class="noviewer" typeof="mw:File"></span></span> <span class="bandeau-portail-texte">Portail de la programmation informatique</span> </span></li> <li><span class="bandeau-portail-element"><span class="bandeau-portail-icone"><span class="noviewer" typeof="mw:File"></span></span> <span class="bandeau-portail-texte">Portail du jeu vidéo</span> </span></li> </ul></div><!--htdig_noindex--><div><div class="zim-footer">
Cet article est issu de <a class="external text" title="Dernière modification le 2025-10-06" href="https://fr.wikipedia.org/wiki/?title=Lua&oldid=229554973">Wikipédia</a>. Sauf mention contraire, le texte est disponible sous <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.fr">Creative Commons Attribution-Share Alike 4.0</a>. Des conditions supplémentaires peuvent s’appliquer aux fichiers multimédias.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>
<script src="./_webp_/webpHandler.js"></script>
</body></html>